import { c as commonjsGlobal } from './_commonjsHelpers-BFTU3MAI.js';
import { r as requireForm_data, a as requireProxyFromEnv, b as requireFollowRedirects } from './index-BRrDHEF2.js';
import require$$0 from 'url';
import require$$3 from 'http';
import require$$4 from 'https';
import require$$1 from 'util';
import zlib from 'zlib';
import stream from 'stream';
import EventEmitter from 'events';
import require$$0$1 from 'os';
import require$$2 from 'path';
import require$$6 from 'fs';

var dist = {};

var api$1 = {};

var axios_1;
var hasRequiredAxios;

function requireAxios () {
	if (hasRequiredAxios) return axios_1;
	hasRequiredAxios = 1;

	const FormData$1 = requireForm_data();
	const url = require$$0;
	const proxyFromEnv = requireProxyFromEnv();
	const http = require$$3;
	const https = require$$4;
	const util = require$$1;
	const followRedirects = requireFollowRedirects();
	const zlib$1 = zlib;
	const stream$1 = stream;
	const EventEmitter$1 = EventEmitter;

	function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }

	const FormData__default = /*#__PURE__*/_interopDefaultLegacy(FormData$1);
	const url__default = /*#__PURE__*/_interopDefaultLegacy(url);
	const http__default = /*#__PURE__*/_interopDefaultLegacy(http);
	const https__default = /*#__PURE__*/_interopDefaultLegacy(https);
	const util__default = /*#__PURE__*/_interopDefaultLegacy(util);
	const followRedirects__default = /*#__PURE__*/_interopDefaultLegacy(followRedirects);
	const zlib__default = /*#__PURE__*/_interopDefaultLegacy(zlib$1);
	const stream__default = /*#__PURE__*/_interopDefaultLegacy(stream$1);
	const EventEmitter__default = /*#__PURE__*/_interopDefaultLegacy(EventEmitter$1);

	function bind(fn, thisArg) {
	  return function wrap() {
	    return fn.apply(thisArg, arguments);
	  };
	}

	// utils is a library of generic helper functions non-specific to axios

	const {toString} = Object.prototype;
	const {getPrototypeOf} = Object;

	const kindOf = (cache => thing => {
	    const str = toString.call(thing);
	    return cache[str] || (cache[str] = str.slice(8, -1).toLowerCase());
	})(Object.create(null));

	const kindOfTest = (type) => {
	  type = type.toLowerCase();
	  return (thing) => kindOf(thing) === type
	};

	const typeOfTest = type => thing => typeof thing === type;

	/**
	 * Determine if a value is an Array
	 *
	 * @param {Object} val The value to test
	 *
	 * @returns {boolean} True if value is an Array, otherwise false
	 */
	const {isArray} = Array;

	/**
	 * Determine if a value is undefined
	 *
	 * @param {*} val The value to test
	 *
	 * @returns {boolean} True if the value is undefined, otherwise false
	 */
	const isUndefined = typeOfTest('undefined');

	/**
	 * Determine if a value is a Buffer
	 *
	 * @param {*} val The value to test
	 *
	 * @returns {boolean} True if value is a Buffer, otherwise false
	 */
	function isBuffer(val) {
	  return val !== null && !isUndefined(val) && val.constructor !== null && !isUndefined(val.constructor)
	    && isFunction(val.constructor.isBuffer) && val.constructor.isBuffer(val);
	}

	/**
	 * Determine if a value is an ArrayBuffer
	 *
	 * @param {*} val The value to test
	 *
	 * @returns {boolean} True if value is an ArrayBuffer, otherwise false
	 */
	const isArrayBuffer = kindOfTest('ArrayBuffer');


	/**
	 * Determine if a value is a view on an ArrayBuffer
	 *
	 * @param {*} val The value to test
	 *
	 * @returns {boolean} True if value is a view on an ArrayBuffer, otherwise false
	 */
	function isArrayBufferView(val) {
	  let result;
	  if ((typeof ArrayBuffer !== 'undefined') && (ArrayBuffer.isView)) {
	    result = ArrayBuffer.isView(val);
	  } else {
	    result = (val) && (val.buffer) && (isArrayBuffer(val.buffer));
	  }
	  return result;
	}

	/**
	 * Determine if a value is a String
	 *
	 * @param {*} val The value to test
	 *
	 * @returns {boolean} True if value is a String, otherwise false
	 */
	const isString = typeOfTest('string');

	/**
	 * Determine if a value is a Function
	 *
	 * @param {*} val The value to test
	 * @returns {boolean} True if value is a Function, otherwise false
	 */
	const isFunction = typeOfTest('function');

	/**
	 * Determine if a value is a Number
	 *
	 * @param {*} val The value to test
	 *
	 * @returns {boolean} True if value is a Number, otherwise false
	 */
	const isNumber = typeOfTest('number');

	/**
	 * Determine if a value is an Object
	 *
	 * @param {*} thing The value to test
	 *
	 * @returns {boolean} True if value is an Object, otherwise false
	 */
	const isObject = (thing) => thing !== null && typeof thing === 'object';

	/**
	 * Determine if a value is a Boolean
	 *
	 * @param {*} thing The value to test
	 * @returns {boolean} True if value is a Boolean, otherwise false
	 */
	const isBoolean = thing => thing === true || thing === false;

	/**
	 * Determine if a value is a plain Object
	 *
	 * @param {*} val The value to test
	 *
	 * @returns {boolean} True if value is a plain Object, otherwise false
	 */
	const isPlainObject = (val) => {
	  if (kindOf(val) !== 'object') {
	    return false;
	  }

	  const prototype = getPrototypeOf(val);
	  return (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(Symbol.toStringTag in val) && !(Symbol.iterator in val);
	};

	/**
	 * Determine if a value is a Date
	 *
	 * @param {*} val The value to test
	 *
	 * @returns {boolean} True if value is a Date, otherwise false
	 */
	const isDate = kindOfTest('Date');

	/**
	 * Determine if a value is a File
	 *
	 * @param {*} val The value to test
	 *
	 * @returns {boolean} True if value is a File, otherwise false
	 */
	const isFile = kindOfTest('File');

	/**
	 * Determine if a value is a Blob
	 *
	 * @param {*} val The value to test
	 *
	 * @returns {boolean} True if value is a Blob, otherwise false
	 */
	const isBlob = kindOfTest('Blob');

	/**
	 * Determine if a value is a FileList
	 *
	 * @param {*} val The value to test
	 *
	 * @returns {boolean} True if value is a File, otherwise false
	 */
	const isFileList = kindOfTest('FileList');

	/**
	 * Determine if a value is a Stream
	 *
	 * @param {*} val The value to test
	 *
	 * @returns {boolean} True if value is a Stream, otherwise false
	 */
	const isStream = (val) => isObject(val) && isFunction(val.pipe);

	/**
	 * Determine if a value is a FormData
	 *
	 * @param {*} thing The value to test
	 *
	 * @returns {boolean} True if value is an FormData, otherwise false
	 */
	const isFormData = (thing) => {
	  let kind;
	  return thing && (
	    (typeof FormData === 'function' && thing instanceof FormData) || (
	      isFunction(thing.append) && (
	        (kind = kindOf(thing)) === 'formdata' ||
	        // detect form-data instance
	        (kind === 'object' && isFunction(thing.toString) && thing.toString() === '[object FormData]')
	      )
	    )
	  )
	};

	/**
	 * Determine if a value is a URLSearchParams object
	 *
	 * @param {*} val The value to test
	 *
	 * @returns {boolean} True if value is a URLSearchParams object, otherwise false
	 */
	const isURLSearchParams = kindOfTest('URLSearchParams');

	/**
	 * Trim excess whitespace off the beginning and end of a string
	 *
	 * @param {String} str The String to trim
	 *
	 * @returns {String} The String freed of excess whitespace
	 */
	const trim = (str) => str.trim ?
	  str.trim() : str.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, '');

	/**
	 * Iterate over an Array or an Object invoking a function for each item.
	 *
	 * If `obj` is an Array callback will be called passing
	 * the value, index, and complete array for each item.
	 *
	 * If 'obj' is an Object callback will be called passing
	 * the value, key, and complete object for each property.
	 *
	 * @param {Object|Array} obj The object to iterate
	 * @param {Function} fn The callback to invoke for each item
	 *
	 * @param {Boolean} [allOwnKeys = false]
	 * @returns {any}
	 */
	function forEach(obj, fn, {allOwnKeys = false} = {}) {
	  // Don't bother if no value provided
	  if (obj === null || typeof obj === 'undefined') {
	    return;
	  }

	  let i;
	  let l;

	  // Force an array if not already something iterable
	  if (typeof obj !== 'object') {
	    /*eslint no-param-reassign:0*/
	    obj = [obj];
	  }

	  if (isArray(obj)) {
	    // Iterate over array values
	    for (i = 0, l = obj.length; i < l; i++) {
	      fn.call(null, obj[i], i, obj);
	    }
	  } else {
	    // Iterate over object keys
	    const keys = allOwnKeys ? Object.getOwnPropertyNames(obj) : Object.keys(obj);
	    const len = keys.length;
	    let key;

	    for (i = 0; i < len; i++) {
	      key = keys[i];
	      fn.call(null, obj[key], key, obj);
	    }
	  }
	}

	function findKey(obj, key) {
	  key = key.toLowerCase();
	  const keys = Object.keys(obj);
	  let i = keys.length;
	  let _key;
	  while (i-- > 0) {
	    _key = keys[i];
	    if (key === _key.toLowerCase()) {
	      return _key;
	    }
	  }
	  return null;
	}

	const _global = (() => {
	  /*eslint no-undef:0*/
	  if (typeof globalThis !== "undefined") return globalThis;
	  return typeof self !== "undefined" ? self : (typeof window !== 'undefined' ? window : commonjsGlobal)
	})();

	const isContextDefined = (context) => !isUndefined(context) && context !== _global;

	/**
	 * Accepts varargs expecting each argument to be an object, then
	 * immutably merges the properties of each object and returns result.
	 *
	 * When multiple objects contain the same key the later object in
	 * the arguments list will take precedence.
	 *
	 * Example:
	 *
	 * ```js
	 * var result = merge({foo: 123}, {foo: 456});
	 * console.log(result.foo); // outputs 456
	 * ```
	 *
	 * @param {Object} obj1 Object to merge
	 *
	 * @returns {Object} Result of all merge properties
	 */
	function merge(/* obj1, obj2, obj3, ... */) {
	  const {caseless} = isContextDefined(this) && this || {};
	  const result = {};
	  const assignValue = (val, key) => {
	    const targetKey = caseless && findKey(result, key) || key;
	    if (isPlainObject(result[targetKey]) && isPlainObject(val)) {
	      result[targetKey] = merge(result[targetKey], val);
	    } else if (isPlainObject(val)) {
	      result[targetKey] = merge({}, val);
	    } else if (isArray(val)) {
	      result[targetKey] = val.slice();
	    } else {
	      result[targetKey] = val;
	    }
	  };

	  for (let i = 0, l = arguments.length; i < l; i++) {
	    arguments[i] && forEach(arguments[i], assignValue);
	  }
	  return result;
	}

	/**
	 * Extends object a by mutably adding to it the properties of object b.
	 *
	 * @param {Object} a The object to be extended
	 * @param {Object} b The object to copy properties from
	 * @param {Object} thisArg The object to bind function to
	 *
	 * @param {Boolean} [allOwnKeys]
	 * @returns {Object} The resulting value of object a
	 */
	const extend = (a, b, thisArg, {allOwnKeys}= {}) => {
	  forEach(b, (val, key) => {
	    if (thisArg && isFunction(val)) {
	      a[key] = bind(val, thisArg);
	    } else {
	      a[key] = val;
	    }
	  }, {allOwnKeys});
	  return a;
	};

	/**
	 * Remove byte order marker. This catches EF BB BF (the UTF-8 BOM)
	 *
	 * @param {string} content with BOM
	 *
	 * @returns {string} content value without BOM
	 */
	const stripBOM = (content) => {
	  if (content.charCodeAt(0) === 0xFEFF) {
	    content = content.slice(1);
	  }
	  return content;
	};

	/**
	 * Inherit the prototype methods from one constructor into another
	 * @param {function} constructor
	 * @param {function} superConstructor
	 * @param {object} [props]
	 * @param {object} [descriptors]
	 *
	 * @returns {void}
	 */
	const inherits = (constructor, superConstructor, props, descriptors) => {
	  constructor.prototype = Object.create(superConstructor.prototype, descriptors);
	  constructor.prototype.constructor = constructor;
	  Object.defineProperty(constructor, 'super', {
	    value: superConstructor.prototype
	  });
	  props && Object.assign(constructor.prototype, props);
	};

	/**
	 * Resolve object with deep prototype chain to a flat object
	 * @param {Object} sourceObj source object
	 * @param {Object} [destObj]
	 * @param {Function|Boolean} [filter]
	 * @param {Function} [propFilter]
	 *
	 * @returns {Object}
	 */
	const toFlatObject = (sourceObj, destObj, filter, propFilter) => {
	  let props;
	  let i;
	  let prop;
	  const merged = {};

	  destObj = destObj || {};
	  // eslint-disable-next-line no-eq-null,eqeqeq
	  if (sourceObj == null) return destObj;

	  do {
	    props = Object.getOwnPropertyNames(sourceObj);
	    i = props.length;
	    while (i-- > 0) {
	      prop = props[i];
	      if ((!propFilter || propFilter(prop, sourceObj, destObj)) && !merged[prop]) {
	        destObj[prop] = sourceObj[prop];
	        merged[prop] = true;
	      }
	    }
	    sourceObj = filter !== false && getPrototypeOf(sourceObj);
	  } while (sourceObj && (!filter || filter(sourceObj, destObj)) && sourceObj !== Object.prototype);

	  return destObj;
	};

	/**
	 * Determines whether a string ends with the characters of a specified string
	 *
	 * @param {String} str
	 * @param {String} searchString
	 * @param {Number} [position= 0]
	 *
	 * @returns {boolean}
	 */
	const endsWith = (str, searchString, position) => {
	  str = String(str);
	  if (position === undefined || position > str.length) {
	    position = str.length;
	  }
	  position -= searchString.length;
	  const lastIndex = str.indexOf(searchString, position);
	  return lastIndex !== -1 && lastIndex === position;
	};


	/**
	 * Returns new array from array like object or null if failed
	 *
	 * @param {*} [thing]
	 *
	 * @returns {?Array}
	 */
	const toArray = (thing) => {
	  if (!thing) return null;
	  if (isArray(thing)) return thing;
	  let i = thing.length;
	  if (!isNumber(i)) return null;
	  const arr = new Array(i);
	  while (i-- > 0) {
	    arr[i] = thing[i];
	  }
	  return arr;
	};

	/**
	 * Checking if the Uint8Array exists and if it does, it returns a function that checks if the
	 * thing passed in is an instance of Uint8Array
	 *
	 * @param {TypedArray}
	 *
	 * @returns {Array}
	 */
	// eslint-disable-next-line func-names
	const isTypedArray = (TypedArray => {
	  // eslint-disable-next-line func-names
	  return thing => {
	    return TypedArray && thing instanceof TypedArray;
	  };
	})(typeof Uint8Array !== 'undefined' && getPrototypeOf(Uint8Array));

	/**
	 * For each entry in the object, call the function with the key and value.
	 *
	 * @param {Object<any, any>} obj - The object to iterate over.
	 * @param {Function} fn - The function to call for each entry.
	 *
	 * @returns {void}
	 */
	const forEachEntry = (obj, fn) => {
	  const generator = obj && obj[Symbol.iterator];

	  const iterator = generator.call(obj);

	  let result;

	  while ((result = iterator.next()) && !result.done) {
	    const pair = result.value;
	    fn.call(obj, pair[0], pair[1]);
	  }
	};

	/**
	 * It takes a regular expression and a string, and returns an array of all the matches
	 *
	 * @param {string} regExp - The regular expression to match against.
	 * @param {string} str - The string to search.
	 *
	 * @returns {Array<boolean>}
	 */
	const matchAll = (regExp, str) => {
	  let matches;
	  const arr = [];

	  while ((matches = regExp.exec(str)) !== null) {
	    arr.push(matches);
	  }

	  return arr;
	};

	/* Checking if the kindOfTest function returns true when passed an HTMLFormElement. */
	const isHTMLForm = kindOfTest('HTMLFormElement');

	const toCamelCase = str => {
	  return str.toLowerCase().replace(/[-_\s]([a-z\d])(\w*)/g,
	    function replacer(m, p1, p2) {
	      return p1.toUpperCase() + p2;
	    }
	  );
	};

	/* Creating a function that will check if an object has a property. */
	const hasOwnProperty = (({hasOwnProperty}) => (obj, prop) => hasOwnProperty.call(obj, prop))(Object.prototype);

	/**
	 * Determine if a value is a RegExp object
	 *
	 * @param {*} val The value to test
	 *
	 * @returns {boolean} True if value is a RegExp object, otherwise false
	 */
	const isRegExp = kindOfTest('RegExp');

	const reduceDescriptors = (obj, reducer) => {
	  const descriptors = Object.getOwnPropertyDescriptors(obj);
	  const reducedDescriptors = {};

	  forEach(descriptors, (descriptor, name) => {
	    let ret;
	    if ((ret = reducer(descriptor, name, obj)) !== false) {
	      reducedDescriptors[name] = ret || descriptor;
	    }
	  });

	  Object.defineProperties(obj, reducedDescriptors);
	};

	/**
	 * Makes all methods read-only
	 * @param {Object} obj
	 */

	const freezeMethods = (obj) => {
	  reduceDescriptors(obj, (descriptor, name) => {
	    // skip restricted props in strict mode
	    if (isFunction(obj) && ['arguments', 'caller', 'callee'].indexOf(name) !== -1) {
	      return false;
	    }

	    const value = obj[name];

	    if (!isFunction(value)) return;

	    descriptor.enumerable = false;

	    if ('writable' in descriptor) {
	      descriptor.writable = false;
	      return;
	    }

	    if (!descriptor.set) {
	      descriptor.set = () => {
	        throw Error('Can not rewrite read-only method \'' + name + '\'');
	      };
	    }
	  });
	};

	const toObjectSet = (arrayOrString, delimiter) => {
	  const obj = {};

	  const define = (arr) => {
	    arr.forEach(value => {
	      obj[value] = true;
	    });
	  };

	  isArray(arrayOrString) ? define(arrayOrString) : define(String(arrayOrString).split(delimiter));

	  return obj;
	};

	const noop = () => {};

	const toFiniteNumber = (value, defaultValue) => {
	  value = +value;
	  return Number.isFinite(value) ? value : defaultValue;
	};

	const ALPHA = 'abcdefghijklmnopqrstuvwxyz';

	const DIGIT = '0123456789';

	const ALPHABET = {
	  DIGIT,
	  ALPHA,
	  ALPHA_DIGIT: ALPHA + ALPHA.toUpperCase() + DIGIT
	};

	const generateString = (size = 16, alphabet = ALPHABET.ALPHA_DIGIT) => {
	  let str = '';
	  const {length} = alphabet;
	  while (size--) {
	    str += alphabet[Math.random() * length|0];
	  }

	  return str;
	};

	/**
	 * If the thing is a FormData object, return true, otherwise return false.
	 *
	 * @param {unknown} thing - The thing to check.
	 *
	 * @returns {boolean}
	 */
	function isSpecCompliantForm(thing) {
	  return !!(thing && isFunction(thing.append) && thing[Symbol.toStringTag] === 'FormData' && thing[Symbol.iterator]);
	}

	const toJSONObject = (obj) => {
	  const stack = new Array(10);

	  const visit = (source, i) => {

	    if (isObject(source)) {
	      if (stack.indexOf(source) >= 0) {
	        return;
	      }

	      if(!('toJSON' in source)) {
	        stack[i] = source;
	        const target = isArray(source) ? [] : {};

	        forEach(source, (value, key) => {
	          const reducedValue = visit(value, i + 1);
	          !isUndefined(reducedValue) && (target[key] = reducedValue);
	        });

	        stack[i] = undefined;

	        return target;
	      }
	    }

	    return source;
	  };

	  return visit(obj, 0);
	};

	const isAsyncFn = kindOfTest('AsyncFunction');

	const isThenable = (thing) =>
	  thing && (isObject(thing) || isFunction(thing)) && isFunction(thing.then) && isFunction(thing.catch);

	const utils$1 = {
	  isArray,
	  isArrayBuffer,
	  isBuffer,
	  isFormData,
	  isArrayBufferView,
	  isString,
	  isNumber,
	  isBoolean,
	  isObject,
	  isPlainObject,
	  isUndefined,
	  isDate,
	  isFile,
	  isBlob,
	  isRegExp,
	  isFunction,
	  isStream,
	  isURLSearchParams,
	  isTypedArray,
	  isFileList,
	  forEach,
	  merge,
	  extend,
	  trim,
	  stripBOM,
	  inherits,
	  toFlatObject,
	  kindOf,
	  kindOfTest,
	  endsWith,
	  toArray,
	  forEachEntry,
	  matchAll,
	  isHTMLForm,
	  hasOwnProperty,
	  hasOwnProp: hasOwnProperty, // an alias to avoid ESLint no-prototype-builtins detection
	  reduceDescriptors,
	  freezeMethods,
	  toObjectSet,
	  toCamelCase,
	  noop,
	  toFiniteNumber,
	  findKey,
	  global: _global,
	  isContextDefined,
	  ALPHABET,
	  generateString,
	  isSpecCompliantForm,
	  toJSONObject,
	  isAsyncFn,
	  isThenable
	};

	/**
	 * Create an Error with the specified message, config, error code, request and response.
	 *
	 * @param {string} message The error message.
	 * @param {string} [code] The error code (for example, 'ECONNABORTED').
	 * @param {Object} [config] The config.
	 * @param {Object} [request] The request.
	 * @param {Object} [response] The response.
	 *
	 * @returns {Error} The created error.
	 */
	function AxiosError(message, code, config, request, response) {
	  Error.call(this);

	  if (Error.captureStackTrace) {
	    Error.captureStackTrace(this, this.constructor);
	  } else {
	    this.stack = (new Error()).stack;
	  }

	  this.message = message;
	  this.name = 'AxiosError';
	  code && (this.code = code);
	  config && (this.config = config);
	  request && (this.request = request);
	  response && (this.response = response);
	}

	utils$1.inherits(AxiosError, Error, {
	  toJSON: function toJSON() {
	    return {
	      // Standard
	      message: this.message,
	      name: this.name,
	      // Microsoft
	      description: this.description,
	      number: this.number,
	      // Mozilla
	      fileName: this.fileName,
	      lineNumber: this.lineNumber,
	      columnNumber: this.columnNumber,
	      stack: this.stack,
	      // Axios
	      config: utils$1.toJSONObject(this.config),
	      code: this.code,
	      status: this.response && this.response.status ? this.response.status : null
	    };
	  }
	});

	const prototype$1 = AxiosError.prototype;
	const descriptors = {};

	[
	  'ERR_BAD_OPTION_VALUE',
	  'ERR_BAD_OPTION',
	  'ECONNABORTED',
	  'ETIMEDOUT',
	  'ERR_NETWORK',
	  'ERR_FR_TOO_MANY_REDIRECTS',
	  'ERR_DEPRECATED',
	  'ERR_BAD_RESPONSE',
	  'ERR_BAD_REQUEST',
	  'ERR_CANCELED',
	  'ERR_NOT_SUPPORT',
	  'ERR_INVALID_URL'
	// eslint-disable-next-line func-names
	].forEach(code => {
	  descriptors[code] = {value: code};
	});

	Object.defineProperties(AxiosError, descriptors);
	Object.defineProperty(prototype$1, 'isAxiosError', {value: true});

	// eslint-disable-next-line func-names
	AxiosError.from = (error, code, config, request, response, customProps) => {
	  const axiosError = Object.create(prototype$1);

	  utils$1.toFlatObject(error, axiosError, function filter(obj) {
	    return obj !== Error.prototype;
	  }, prop => {
	    return prop !== 'isAxiosError';
	  });

	  AxiosError.call(axiosError, error.message, code, config, request, response);

	  axiosError.cause = error;

	  axiosError.name = error.name;

	  customProps && Object.assign(axiosError, customProps);

	  return axiosError;
	};

	/**
	 * Determines if the given thing is a array or js object.
	 *
	 * @param {string} thing - The object or array to be visited.
	 *
	 * @returns {boolean}
	 */
	function isVisitable(thing) {
	  return utils$1.isPlainObject(thing) || utils$1.isArray(thing);
	}

	/**
	 * It removes the brackets from the end of a string
	 *
	 * @param {string} key - The key of the parameter.
	 *
	 * @returns {string} the key without the brackets.
	 */
	function removeBrackets(key) {
	  return utils$1.endsWith(key, '[]') ? key.slice(0, -2) : key;
	}

	/**
	 * It takes a path, a key, and a boolean, and returns a string
	 *
	 * @param {string} path - The path to the current key.
	 * @param {string} key - The key of the current object being iterated over.
	 * @param {string} dots - If true, the key will be rendered with dots instead of brackets.
	 *
	 * @returns {string} The path to the current key.
	 */
	function renderKey(path, key, dots) {
	  if (!path) return key;
	  return path.concat(key).map(function each(token, i) {
	    // eslint-disable-next-line no-param-reassign
	    token = removeBrackets(token);
	    return !dots && i ? '[' + token + ']' : token;
	  }).join(dots ? '.' : '');
	}

	/**
	 * If the array is an array and none of its elements are visitable, then it's a flat array.
	 *
	 * @param {Array<any>} arr - The array to check
	 *
	 * @returns {boolean}
	 */
	function isFlatArray(arr) {
	  return utils$1.isArray(arr) && !arr.some(isVisitable);
	}

	const predicates = utils$1.toFlatObject(utils$1, {}, null, function filter(prop) {
	  return /^is[A-Z]/.test(prop);
	});

	/**
	 * Convert a data object to FormData
	 *
	 * @param {Object} obj
	 * @param {?Object} [formData]
	 * @param {?Object} [options]
	 * @param {Function} [options.visitor]
	 * @param {Boolean} [options.metaTokens = true]
	 * @param {Boolean} [options.dots = false]
	 * @param {?Boolean} [options.indexes = false]
	 *
	 * @returns {Object}
	 **/

	/**
	 * It converts an object into a FormData object
	 *
	 * @param {Object<any, any>} obj - The object to convert to form data.
	 * @param {string} formData - The FormData object to append to.
	 * @param {Object<string, any>} options
	 *
	 * @returns
	 */
	function toFormData(obj, formData, options) {
	  if (!utils$1.isObject(obj)) {
	    throw new TypeError('target must be an object');
	  }

	  // eslint-disable-next-line no-param-reassign
	  formData = formData || new (FormData__default["default"] || FormData)();

	  // eslint-disable-next-line no-param-reassign
	  options = utils$1.toFlatObject(options, {
	    metaTokens: true,
	    dots: false,
	    indexes: false
	  }, false, function defined(option, source) {
	    // eslint-disable-next-line no-eq-null,eqeqeq
	    return !utils$1.isUndefined(source[option]);
	  });

	  const metaTokens = options.metaTokens;
	  // eslint-disable-next-line no-use-before-define
	  const visitor = options.visitor || defaultVisitor;
	  const dots = options.dots;
	  const indexes = options.indexes;
	  const _Blob = options.Blob || typeof Blob !== 'undefined' && Blob;
	  const useBlob = _Blob && utils$1.isSpecCompliantForm(formData);

	  if (!utils$1.isFunction(visitor)) {
	    throw new TypeError('visitor must be a function');
	  }

	  function convertValue(value) {
	    if (value === null) return '';

	    if (utils$1.isDate(value)) {
	      return value.toISOString();
	    }

	    if (!useBlob && utils$1.isBlob(value)) {
	      throw new AxiosError('Blob is not supported. Use a Buffer instead.');
	    }

	    if (utils$1.isArrayBuffer(value) || utils$1.isTypedArray(value)) {
	      return useBlob && typeof Blob === 'function' ? new Blob([value]) : Buffer.from(value);
	    }

	    return value;
	  }

	  /**
	   * Default visitor.
	   *
	   * @param {*} value
	   * @param {String|Number} key
	   * @param {Array<String|Number>} path
	   * @this {FormData}
	   *
	   * @returns {boolean} return true to visit the each prop of the value recursively
	   */
	  function defaultVisitor(value, key, path) {
	    let arr = value;

	    if (value && !path && typeof value === 'object') {
	      if (utils$1.endsWith(key, '{}')) {
	        // eslint-disable-next-line no-param-reassign
	        key = metaTokens ? key : key.slice(0, -2);
	        // eslint-disable-next-line no-param-reassign
	        value = JSON.stringify(value);
	      } else if (
	        (utils$1.isArray(value) && isFlatArray(value)) ||
	        ((utils$1.isFileList(value) || utils$1.endsWith(key, '[]')) && (arr = utils$1.toArray(value))
	        )) {
	        // eslint-disable-next-line no-param-reassign
	        key = removeBrackets(key);

	        arr.forEach(function each(el, index) {
	          !(utils$1.isUndefined(el) || el === null) && formData.append(
	            // eslint-disable-next-line no-nested-ternary
	            indexes === true ? renderKey([key], index, dots) : (indexes === null ? key : key + '[]'),
	            convertValue(el)
	          );
	        });
	        return false;
	      }
	    }

	    if (isVisitable(value)) {
	      return true;
	    }

	    formData.append(renderKey(path, key, dots), convertValue(value));

	    return false;
	  }

	  const stack = [];

	  const exposedHelpers = Object.assign(predicates, {
	    defaultVisitor,
	    convertValue,
	    isVisitable
	  });

	  function build(value, path) {
	    if (utils$1.isUndefined(value)) return;

	    if (stack.indexOf(value) !== -1) {
	      throw Error('Circular reference detected in ' + path.join('.'));
	    }

	    stack.push(value);

	    utils$1.forEach(value, function each(el, key) {
	      const result = !(utils$1.isUndefined(el) || el === null) && visitor.call(
	        formData, el, utils$1.isString(key) ? key.trim() : key, path, exposedHelpers
	      );

	      if (result === true) {
	        build(el, path ? path.concat(key) : [key]);
	      }
	    });

	    stack.pop();
	  }

	  if (!utils$1.isObject(obj)) {
	    throw new TypeError('data must be an object');
	  }

	  build(obj);

	  return formData;
	}

	/**
	 * It encodes a string by replacing all characters that are not in the unreserved set with
	 * their percent-encoded equivalents
	 *
	 * @param {string} str - The string to encode.
	 *
	 * @returns {string} The encoded string.
	 */
	function encode$1(str) {
	  const charMap = {
	    '!': '%21',
	    "'": '%27',
	    '(': '%28',
	    ')': '%29',
	    '~': '%7E',
	    '%20': '+',
	    '%00': '\x00'
	  };
	  return encodeURIComponent(str).replace(/[!'()~]|%20|%00/g, function replacer(match) {
	    return charMap[match];
	  });
	}

	/**
	 * It takes a params object and converts it to a FormData object
	 *
	 * @param {Object<string, any>} params - The parameters to be converted to a FormData object.
	 * @param {Object<string, any>} options - The options object passed to the Axios constructor.
	 *
	 * @returns {void}
	 */
	function AxiosURLSearchParams(params, options) {
	  this._pairs = [];

	  params && toFormData(params, this, options);
	}

	const prototype = AxiosURLSearchParams.prototype;

	prototype.append = function append(name, value) {
	  this._pairs.push([name, value]);
	};

	prototype.toString = function toString(encoder) {
	  const _encode = encoder ? function(value) {
	    return encoder.call(this, value, encode$1);
	  } : encode$1;

	  return this._pairs.map(function each(pair) {
	    return _encode(pair[0]) + '=' + _encode(pair[1]);
	  }, '').join('&');
	};

	/**
	 * It replaces all instances of the characters `:`, `$`, `,`, `+`, `[`, and `]` with their
	 * URI encoded counterparts
	 *
	 * @param {string} val The value to be encoded.
	 *
	 * @returns {string} The encoded value.
	 */
	function encode(val) {
	  return encodeURIComponent(val).
	    replace(/%3A/gi, ':').
	    replace(/%24/g, '$').
	    replace(/%2C/gi, ',').
	    replace(/%20/g, '+').
	    replace(/%5B/gi, '[').
	    replace(/%5D/gi, ']');
	}

	/**
	 * Build a URL by appending params to the end
	 *
	 * @param {string} url The base of the url (e.g., http://www.google.com)
	 * @param {object} [params] The params to be appended
	 * @param {?object} options
	 *
	 * @returns {string} The formatted url
	 */
	function buildURL(url, params, options) {
	  /*eslint no-param-reassign:0*/
	  if (!params) {
	    return url;
	  }
	  
	  const _encode = options && options.encode || encode;

	  const serializeFn = options && options.serialize;

	  let serializedParams;

	  if (serializeFn) {
	    serializedParams = serializeFn(params, options);
	  } else {
	    serializedParams = utils$1.isURLSearchParams(params) ?
	      params.toString() :
	      new AxiosURLSearchParams(params, options).toString(_encode);
	  }

	  if (serializedParams) {
	    const hashmarkIndex = url.indexOf("#");

	    if (hashmarkIndex !== -1) {
	      url = url.slice(0, hashmarkIndex);
	    }
	    url += (url.indexOf('?') === -1 ? '?' : '&') + serializedParams;
	  }

	  return url;
	}

	class InterceptorManager {
	  constructor() {
	    this.handlers = [];
	  }

	  /**
	   * Add a new interceptor to the stack
	   *
	   * @param {Function} fulfilled The function to handle `then` for a `Promise`
	   * @param {Function} rejected The function to handle `reject` for a `Promise`
	   *
	   * @return {Number} An ID used to remove interceptor later
	   */
	  use(fulfilled, rejected, options) {
	    this.handlers.push({
	      fulfilled,
	      rejected,
	      synchronous: options ? options.synchronous : false,
	      runWhen: options ? options.runWhen : null
	    });
	    return this.handlers.length - 1;
	  }

	  /**
	   * Remove an interceptor from the stack
	   *
	   * @param {Number} id The ID that was returned by `use`
	   *
	   * @returns {Boolean} `true` if the interceptor was removed, `false` otherwise
	   */
	  eject(id) {
	    if (this.handlers[id]) {
	      this.handlers[id] = null;
	    }
	  }

	  /**
	   * Clear all interceptors from the stack
	   *
	   * @returns {void}
	   */
	  clear() {
	    if (this.handlers) {
	      this.handlers = [];
	    }
	  }

	  /**
	   * Iterate over all the registered interceptors
	   *
	   * This method is particularly useful for skipping over any
	   * interceptors that may have become `null` calling `eject`.
	   *
	   * @param {Function} fn The function to call for each interceptor
	   *
	   * @returns {void}
	   */
	  forEach(fn) {
	    utils$1.forEach(this.handlers, function forEachHandler(h) {
	      if (h !== null) {
	        fn(h);
	      }
	    });
	  }
	}

	const InterceptorManager$1 = InterceptorManager;

	const transitionalDefaults = {
	  silentJSONParsing: true,
	  forcedJSONParsing: true,
	  clarifyTimeoutError: false
	};

	const URLSearchParams = url__default["default"].URLSearchParams;

	const platform$1 = {
	  isNode: true,
	  classes: {
	    URLSearchParams,
	    FormData: FormData__default["default"],
	    Blob: typeof Blob !== 'undefined' && Blob || null
	  },
	  protocols: [ 'http', 'https', 'file', 'data' ]
	};

	const hasBrowserEnv = typeof window !== 'undefined' && typeof document !== 'undefined';

	/**
	 * Determine if we're running in a standard browser environment
	 *
	 * This allows axios to run in a web worker, and react-native.
	 * Both environments support XMLHttpRequest, but not fully standard globals.
	 *
	 * web workers:
	 *  typeof window -> undefined
	 *  typeof document -> undefined
	 *
	 * react-native:
	 *  navigator.product -> 'ReactNative'
	 * nativescript
	 *  navigator.product -> 'NativeScript' or 'NS'
	 *
	 * @returns {boolean}
	 */
	const hasStandardBrowserEnv = (
	  (product) => {
	    return hasBrowserEnv && ['ReactNative', 'NativeScript', 'NS'].indexOf(product) < 0
	  })(typeof navigator !== 'undefined' && navigator.product);

	/**
	 * Determine if we're running in a standard browser webWorker environment
	 *
	 * Although the `isStandardBrowserEnv` method indicates that
	 * `allows axios to run in a web worker`, the WebWorker will still be
	 * filtered out due to its judgment standard
	 * `typeof window !== 'undefined' && typeof document !== 'undefined'`.
	 * This leads to a problem when axios post `FormData` in webWorker
	 */
	const hasStandardBrowserWebWorkerEnv = (() => {
	  return (
	    typeof WorkerGlobalScope !== 'undefined' &&
	    // eslint-disable-next-line no-undef
	    self instanceof WorkerGlobalScope &&
	    typeof self.importScripts === 'function'
	  );
	})();

	const utils = /*#__PURE__*/Object.freeze({
	  __proto__: null,
	  hasBrowserEnv: hasBrowserEnv,
	  hasStandardBrowserWebWorkerEnv: hasStandardBrowserWebWorkerEnv,
	  hasStandardBrowserEnv: hasStandardBrowserEnv
	});

	const platform = {
	  ...utils,
	  ...platform$1
	};

	function toURLEncodedForm(data, options) {
	  return toFormData(data, new platform.classes.URLSearchParams(), Object.assign({
	    visitor: function(value, key, path, helpers) {
	      if (platform.isNode && utils$1.isBuffer(value)) {
	        this.append(key, value.toString('base64'));
	        return false;
	      }

	      return helpers.defaultVisitor.apply(this, arguments);
	    }
	  }, options));
	}

	/**
	 * It takes a string like `foo[x][y][z]` and returns an array like `['foo', 'x', 'y', 'z']
	 *
	 * @param {string} name - The name of the property to get.
	 *
	 * @returns An array of strings.
	 */
	function parsePropPath(name) {
	  // foo[x][y][z]
	  // foo.x.y.z
	  // foo-x-y-z
	  // foo x y z
	  return utils$1.matchAll(/\w+|\[(\w*)]/g, name).map(match => {
	    return match[0] === '[]' ? '' : match[1] || match[0];
	  });
	}

	/**
	 * Convert an array to an object.
	 *
	 * @param {Array<any>} arr - The array to convert to an object.
	 *
	 * @returns An object with the same keys and values as the array.
	 */
	function arrayToObject(arr) {
	  const obj = {};
	  const keys = Object.keys(arr);
	  let i;
	  const len = keys.length;
	  let key;
	  for (i = 0; i < len; i++) {
	    key = keys[i];
	    obj[key] = arr[key];
	  }
	  return obj;
	}

	/**
	 * It takes a FormData object and returns a JavaScript object
	 *
	 * @param {string} formData The FormData object to convert to JSON.
	 *
	 * @returns {Object<string, any> | null} The converted object.
	 */
	function formDataToJSON(formData) {
	  function buildPath(path, value, target, index) {
	    let name = path[index++];

	    if (name === '__proto__') return true;

	    const isNumericKey = Number.isFinite(+name);
	    const isLast = index >= path.length;
	    name = !name && utils$1.isArray(target) ? target.length : name;

	    if (isLast) {
	      if (utils$1.hasOwnProp(target, name)) {
	        target[name] = [target[name], value];
	      } else {
	        target[name] = value;
	      }

	      return !isNumericKey;
	    }

	    if (!target[name] || !utils$1.isObject(target[name])) {
	      target[name] = [];
	    }

	    const result = buildPath(path, value, target[name], index);

	    if (result && utils$1.isArray(target[name])) {
	      target[name] = arrayToObject(target[name]);
	    }

	    return !isNumericKey;
	  }

	  if (utils$1.isFormData(formData) && utils$1.isFunction(formData.entries)) {
	    const obj = {};

	    utils$1.forEachEntry(formData, (name, value) => {
	      buildPath(parsePropPath(name), value, obj, 0);
	    });

	    return obj;
	  }

	  return null;
	}

	/**
	 * It takes a string, tries to parse it, and if it fails, it returns the stringified version
	 * of the input
	 *
	 * @param {any} rawValue - The value to be stringified.
	 * @param {Function} parser - A function that parses a string into a JavaScript object.
	 * @param {Function} encoder - A function that takes a value and returns a string.
	 *
	 * @returns {string} A stringified version of the rawValue.
	 */
	function stringifySafely(rawValue, parser, encoder) {
	  if (utils$1.isString(rawValue)) {
	    try {
	      (parser || JSON.parse)(rawValue);
	      return utils$1.trim(rawValue);
	    } catch (e) {
	      if (e.name !== 'SyntaxError') {
	        throw e;
	      }
	    }
	  }

	  return (encoder || JSON.stringify)(rawValue);
	}

	const defaults = {

	  transitional: transitionalDefaults,

	  adapter: ['xhr', 'http'],

	  transformRequest: [function transformRequest(data, headers) {
	    const contentType = headers.getContentType() || '';
	    const hasJSONContentType = contentType.indexOf('application/json') > -1;
	    const isObjectPayload = utils$1.isObject(data);

	    if (isObjectPayload && utils$1.isHTMLForm(data)) {
	      data = new FormData(data);
	    }

	    const isFormData = utils$1.isFormData(data);

	    if (isFormData) {
	      return hasJSONContentType ? JSON.stringify(formDataToJSON(data)) : data;
	    }

	    if (utils$1.isArrayBuffer(data) ||
	      utils$1.isBuffer(data) ||
	      utils$1.isStream(data) ||
	      utils$1.isFile(data) ||
	      utils$1.isBlob(data)
	    ) {
	      return data;
	    }
	    if (utils$1.isArrayBufferView(data)) {
	      return data.buffer;
	    }
	    if (utils$1.isURLSearchParams(data)) {
	      headers.setContentType('application/x-www-form-urlencoded;charset=utf-8', false);
	      return data.toString();
	    }

	    let isFileList;

	    if (isObjectPayload) {
	      if (contentType.indexOf('application/x-www-form-urlencoded') > -1) {
	        return toURLEncodedForm(data, this.formSerializer).toString();
	      }

	      if ((isFileList = utils$1.isFileList(data)) || contentType.indexOf('multipart/form-data') > -1) {
	        const _FormData = this.env && this.env.FormData;

	        return toFormData(
	          isFileList ? {'files[]': data} : data,
	          _FormData && new _FormData(),
	          this.formSerializer
	        );
	      }
	    }

	    if (isObjectPayload || hasJSONContentType ) {
	      headers.setContentType('application/json', false);
	      return stringifySafely(data);
	    }

	    return data;
	  }],

	  transformResponse: [function transformResponse(data) {
	    const transitional = this.transitional || defaults.transitional;
	    const forcedJSONParsing = transitional && transitional.forcedJSONParsing;
	    const JSONRequested = this.responseType === 'json';

	    if (data && utils$1.isString(data) && ((forcedJSONParsing && !this.responseType) || JSONRequested)) {
	      const silentJSONParsing = transitional && transitional.silentJSONParsing;
	      const strictJSONParsing = !silentJSONParsing && JSONRequested;

	      try {
	        return JSON.parse(data);
	      } catch (e) {
	        if (strictJSONParsing) {
	          if (e.name === 'SyntaxError') {
	            throw AxiosError.from(e, AxiosError.ERR_BAD_RESPONSE, this, null, this.response);
	          }
	          throw e;
	        }
	      }
	    }

	    return data;
	  }],

	  /**
	   * A timeout in milliseconds to abort a request. If set to 0 (default) a
	   * timeout is not created.
	   */
	  timeout: 0,

	  xsrfCookieName: 'XSRF-TOKEN',
	  xsrfHeaderName: 'X-XSRF-TOKEN',

	  maxContentLength: -1,
	  maxBodyLength: -1,

	  env: {
	    FormData: platform.classes.FormData,
	    Blob: platform.classes.Blob
	  },

	  validateStatus: function validateStatus(status) {
	    return status >= 200 && status < 300;
	  },

	  headers: {
	    common: {
	      'Accept': 'application/json, text/plain, */*',
	      'Content-Type': undefined
	    }
	  }
	};

	utils$1.forEach(['delete', 'get', 'head', 'post', 'put', 'patch'], (method) => {
	  defaults.headers[method] = {};
	});

	const defaults$1 = defaults;

	// RawAxiosHeaders whose duplicates are ignored by node
	// c.f. https://nodejs.org/api/http.html#http_message_headers
	const ignoreDuplicateOf = utils$1.toObjectSet([
	  'age', 'authorization', 'content-length', 'content-type', 'etag',
	  'expires', 'from', 'host', 'if-modified-since', 'if-unmodified-since',
	  'last-modified', 'location', 'max-forwards', 'proxy-authorization',
	  'referer', 'retry-after', 'user-agent'
	]);

	/**
	 * Parse headers into an object
	 *
	 * ```
	 * Date: Wed, 27 Aug 2014 08:58:49 GMT
	 * Content-Type: application/json
	 * Connection: keep-alive
	 * Transfer-Encoding: chunked
	 * ```
	 *
	 * @param {String} rawHeaders Headers needing to be parsed
	 *
	 * @returns {Object} Headers parsed into an object
	 */
	const parseHeaders = rawHeaders => {
	  const parsed = {};
	  let key;
	  let val;
	  let i;

	  rawHeaders && rawHeaders.split('\n').forEach(function parser(line) {
	    i = line.indexOf(':');
	    key = line.substring(0, i).trim().toLowerCase();
	    val = line.substring(i + 1).trim();

	    if (!key || (parsed[key] && ignoreDuplicateOf[key])) {
	      return;
	    }

	    if (key === 'set-cookie') {
	      if (parsed[key]) {
	        parsed[key].push(val);
	      } else {
	        parsed[key] = [val];
	      }
	    } else {
	      parsed[key] = parsed[key] ? parsed[key] + ', ' + val : val;
	    }
	  });

	  return parsed;
	};

	const $internals = Symbol('internals');

	function normalizeHeader(header) {
	  return header && String(header).trim().toLowerCase();
	}

	function normalizeValue(value) {
	  if (value === false || value == null) {
	    return value;
	  }

	  return utils$1.isArray(value) ? value.map(normalizeValue) : String(value);
	}

	function parseTokens(str) {
	  const tokens = Object.create(null);
	  const tokensRE = /([^\s,;=]+)\s*(?:=\s*([^,;]+))?/g;
	  let match;

	  while ((match = tokensRE.exec(str))) {
	    tokens[match[1]] = match[2];
	  }

	  return tokens;
	}

	const isValidHeaderName = (str) => /^[-_a-zA-Z0-9^`|~,!#$%&'*+.]+$/.test(str.trim());

	function matchHeaderValue(context, value, header, filter, isHeaderNameFilter) {
	  if (utils$1.isFunction(filter)) {
	    return filter.call(this, value, header);
	  }

	  if (isHeaderNameFilter) {
	    value = header;
	  }

	  if (!utils$1.isString(value)) return;

	  if (utils$1.isString(filter)) {
	    return value.indexOf(filter) !== -1;
	  }

	  if (utils$1.isRegExp(filter)) {
	    return filter.test(value);
	  }
	}

	function formatHeader(header) {
	  return header.trim()
	    .toLowerCase().replace(/([a-z\d])(\w*)/g, (w, char, str) => {
	      return char.toUpperCase() + str;
	    });
	}

	function buildAccessors(obj, header) {
	  const accessorName = utils$1.toCamelCase(' ' + header);

	  ['get', 'set', 'has'].forEach(methodName => {
	    Object.defineProperty(obj, methodName + accessorName, {
	      value: function(arg1, arg2, arg3) {
	        return this[methodName].call(this, header, arg1, arg2, arg3);
	      },
	      configurable: true
	    });
	  });
	}

	class AxiosHeaders {
	  constructor(headers) {
	    headers && this.set(headers);
	  }

	  set(header, valueOrRewrite, rewrite) {
	    const self = this;

	    function setHeader(_value, _header, _rewrite) {
	      const lHeader = normalizeHeader(_header);

	      if (!lHeader) {
	        throw new Error('header name must be a non-empty string');
	      }

	      const key = utils$1.findKey(self, lHeader);

	      if(!key || self[key] === undefined || _rewrite === true || (_rewrite === undefined && self[key] !== false)) {
	        self[key || _header] = normalizeValue(_value);
	      }
	    }

	    const setHeaders = (headers, _rewrite) =>
	      utils$1.forEach(headers, (_value, _header) => setHeader(_value, _header, _rewrite));

	    if (utils$1.isPlainObject(header) || header instanceof this.constructor) {
	      setHeaders(header, valueOrRewrite);
	    } else if(utils$1.isString(header) && (header = header.trim()) && !isValidHeaderName(header)) {
	      setHeaders(parseHeaders(header), valueOrRewrite);
	    } else {
	      header != null && setHeader(valueOrRewrite, header, rewrite);
	    }

	    return this;
	  }

	  get(header, parser) {
	    header = normalizeHeader(header);

	    if (header) {
	      const key = utils$1.findKey(this, header);

	      if (key) {
	        const value = this[key];

	        if (!parser) {
	          return value;
	        }

	        if (parser === true) {
	          return parseTokens(value);
	        }

	        if (utils$1.isFunction(parser)) {
	          return parser.call(this, value, key);
	        }

	        if (utils$1.isRegExp(parser)) {
	          return parser.exec(value);
	        }

	        throw new TypeError('parser must be boolean|regexp|function');
	      }
	    }
	  }

	  has(header, matcher) {
	    header = normalizeHeader(header);

	    if (header) {
	      const key = utils$1.findKey(this, header);

	      return !!(key && this[key] !== undefined && (!matcher || matchHeaderValue(this, this[key], key, matcher)));
	    }

	    return false;
	  }

	  delete(header, matcher) {
	    const self = this;
	    let deleted = false;

	    function deleteHeader(_header) {
	      _header = normalizeHeader(_header);

	      if (_header) {
	        const key = utils$1.findKey(self, _header);

	        if (key && (!matcher || matchHeaderValue(self, self[key], key, matcher))) {
	          delete self[key];

	          deleted = true;
	        }
	      }
	    }

	    if (utils$1.isArray(header)) {
	      header.forEach(deleteHeader);
	    } else {
	      deleteHeader(header);
	    }

	    return deleted;
	  }

	  clear(matcher) {
	    const keys = Object.keys(this);
	    let i = keys.length;
	    let deleted = false;

	    while (i--) {
	      const key = keys[i];
	      if(!matcher || matchHeaderValue(this, this[key], key, matcher, true)) {
	        delete this[key];
	        deleted = true;
	      }
	    }

	    return deleted;
	  }

	  normalize(format) {
	    const self = this;
	    const headers = {};

	    utils$1.forEach(this, (value, header) => {
	      const key = utils$1.findKey(headers, header);

	      if (key) {
	        self[key] = normalizeValue(value);
	        delete self[header];
	        return;
	      }

	      const normalized = format ? formatHeader(header) : String(header).trim();

	      if (normalized !== header) {
	        delete self[header];
	      }

	      self[normalized] = normalizeValue(value);

	      headers[normalized] = true;
	    });

	    return this;
	  }

	  concat(...targets) {
	    return this.constructor.concat(this, ...targets);
	  }

	  toJSON(asStrings) {
	    const obj = Object.create(null);

	    utils$1.forEach(this, (value, header) => {
	      value != null && value !== false && (obj[header] = asStrings && utils$1.isArray(value) ? value.join(', ') : value);
	    });

	    return obj;
	  }

	  [Symbol.iterator]() {
	    return Object.entries(this.toJSON())[Symbol.iterator]();
	  }

	  toString() {
	    return Object.entries(this.toJSON()).map(([header, value]) => header + ': ' + value).join('\n');
	  }

	  get [Symbol.toStringTag]() {
	    return 'AxiosHeaders';
	  }

	  static from(thing) {
	    return thing instanceof this ? thing : new this(thing);
	  }

	  static concat(first, ...targets) {
	    const computed = new this(first);

	    targets.forEach((target) => computed.set(target));

	    return computed;
	  }

	  static accessor(header) {
	    const internals = this[$internals] = (this[$internals] = {
	      accessors: {}
	    });

	    const accessors = internals.accessors;
	    const prototype = this.prototype;

	    function defineAccessor(_header) {
	      const lHeader = normalizeHeader(_header);

	      if (!accessors[lHeader]) {
	        buildAccessors(prototype, _header);
	        accessors[lHeader] = true;
	      }
	    }

	    utils$1.isArray(header) ? header.forEach(defineAccessor) : defineAccessor(header);

	    return this;
	  }
	}

	AxiosHeaders.accessor(['Content-Type', 'Content-Length', 'Accept', 'Accept-Encoding', 'User-Agent', 'Authorization']);

	// reserved names hotfix
	utils$1.reduceDescriptors(AxiosHeaders.prototype, ({value}, key) => {
	  let mapped = key[0].toUpperCase() + key.slice(1); // map `set` => `Set`
	  return {
	    get: () => value,
	    set(headerValue) {
	      this[mapped] = headerValue;
	    }
	  }
	});

	utils$1.freezeMethods(AxiosHeaders);

	const AxiosHeaders$1 = AxiosHeaders;

	/**
	 * Transform the data for a request or a response
	 *
	 * @param {Array|Function} fns A single function or Array of functions
	 * @param {?Object} response The response object
	 *
	 * @returns {*} The resulting transformed data
	 */
	function transformData(fns, response) {
	  const config = this || defaults$1;
	  const context = response || config;
	  const headers = AxiosHeaders$1.from(context.headers);
	  let data = context.data;

	  utils$1.forEach(fns, function transform(fn) {
	    data = fn.call(config, data, headers.normalize(), response ? response.status : undefined);
	  });

	  headers.normalize();

	  return data;
	}

	function isCancel(value) {
	  return !!(value && value.__CANCEL__);
	}

	/**
	 * A `CanceledError` is an object that is thrown when an operation is canceled.
	 *
	 * @param {string=} message The message.
	 * @param {Object=} config The config.
	 * @param {Object=} request The request.
	 *
	 * @returns {CanceledError} The created error.
	 */
	function CanceledError(message, config, request) {
	  // eslint-disable-next-line no-eq-null,eqeqeq
	  AxiosError.call(this, message == null ? 'canceled' : message, AxiosError.ERR_CANCELED, config, request);
	  this.name = 'CanceledError';
	}

	utils$1.inherits(CanceledError, AxiosError, {
	  __CANCEL__: true
	});

	/**
	 * Resolve or reject a Promise based on response status.
	 *
	 * @param {Function} resolve A function that resolves the promise.
	 * @param {Function} reject A function that rejects the promise.
	 * @param {object} response The response.
	 *
	 * @returns {object} The response.
	 */
	function settle(resolve, reject, response) {
	  const validateStatus = response.config.validateStatus;
	  if (!response.status || !validateStatus || validateStatus(response.status)) {
	    resolve(response);
	  } else {
	    reject(new AxiosError(
	      'Request failed with status code ' + response.status,
	      [AxiosError.ERR_BAD_REQUEST, AxiosError.ERR_BAD_RESPONSE][Math.floor(response.status / 100) - 4],
	      response.config,
	      response.request,
	      response
	    ));
	  }
	}

	/**
	 * Determines whether the specified URL is absolute
	 *
	 * @param {string} url The URL to test
	 *
	 * @returns {boolean} True if the specified URL is absolute, otherwise false
	 */
	function isAbsoluteURL(url) {
	  // A URL is considered absolute if it begins with "<scheme>://" or "//" (protocol-relative URL).
	  // RFC 3986 defines scheme name as a sequence of characters beginning with a letter and followed
	  // by any combination of letters, digits, plus, period, or hyphen.
	  return /^([a-z][a-z\d+\-.]*:)?\/\//i.test(url);
	}

	/**
	 * Creates a new URL by combining the specified URLs
	 *
	 * @param {string} baseURL The base URL
	 * @param {string} relativeURL The relative URL
	 *
	 * @returns {string} The combined URL
	 */
	function combineURLs(baseURL, relativeURL) {
	  return relativeURL
	    ? baseURL.replace(/\/?\/$/, '') + '/' + relativeURL.replace(/^\/+/, '')
	    : baseURL;
	}

	/**
	 * Creates a new URL by combining the baseURL with the requestedURL,
	 * only when the requestedURL is not already an absolute URL.
	 * If the requestURL is absolute, this function returns the requestedURL untouched.
	 *
	 * @param {string} baseURL The base URL
	 * @param {string} requestedURL Absolute or relative URL to combine
	 *
	 * @returns {string} The combined full path
	 */
	function buildFullPath(baseURL, requestedURL) {
	  if (baseURL && !isAbsoluteURL(requestedURL)) {
	    return combineURLs(baseURL, requestedURL);
	  }
	  return requestedURL;
	}

	const VERSION = "1.6.7";

	function parseProtocol(url) {
	  const match = /^([-+\w]{1,25})(:?\/\/|:)/.exec(url);
	  return match && match[1] || '';
	}

	const DATA_URL_PATTERN = /^(?:([^;]+);)?(?:[^;]+;)?(base64|),([\s\S]*)$/;

	/**
	 * Parse data uri to a Buffer or Blob
	 *
	 * @param {String} uri
	 * @param {?Boolean} asBlob
	 * @param {?Object} options
	 * @param {?Function} options.Blob
	 *
	 * @returns {Buffer|Blob}
	 */
	function fromDataURI(uri, asBlob, options) {
	  const _Blob = options && options.Blob || platform.classes.Blob;
	  const protocol = parseProtocol(uri);

	  if (asBlob === undefined && _Blob) {
	    asBlob = true;
	  }

	  if (protocol === 'data') {
	    uri = protocol.length ? uri.slice(protocol.length + 1) : uri;

	    const match = DATA_URL_PATTERN.exec(uri);

	    if (!match) {
	      throw new AxiosError('Invalid URL', AxiosError.ERR_INVALID_URL);
	    }

	    const mime = match[1];
	    const isBase64 = match[2];
	    const body = match[3];
	    const buffer = Buffer.from(decodeURIComponent(body), isBase64 ? 'base64' : 'utf8');

	    if (asBlob) {
	      if (!_Blob) {
	        throw new AxiosError('Blob is not supported', AxiosError.ERR_NOT_SUPPORT);
	      }

	      return new _Blob([buffer], {type: mime});
	    }

	    return buffer;
	  }

	  throw new AxiosError('Unsupported protocol ' + protocol, AxiosError.ERR_NOT_SUPPORT);
	}

	/**
	 * Throttle decorator
	 * @param {Function} fn
	 * @param {Number} freq
	 * @return {Function}
	 */
	function throttle(fn, freq) {
	  let timestamp = 0;
	  const threshold = 1000 / freq;
	  let timer = null;
	  return function throttled(force, args) {
	    const now = Date.now();
	    if (force || now - timestamp > threshold) {
	      if (timer) {
	        clearTimeout(timer);
	        timer = null;
	      }
	      timestamp = now;
	      return fn.apply(null, args);
	    }
	    if (!timer) {
	      timer = setTimeout(() => {
	        timer = null;
	        timestamp = Date.now();
	        return fn.apply(null, args);
	      }, threshold - (now - timestamp));
	    }
	  };
	}

	/**
	 * Calculate data maxRate
	 * @param {Number} [samplesCount= 10]
	 * @param {Number} [min= 1000]
	 * @returns {Function}
	 */
	function speedometer(samplesCount, min) {
	  samplesCount = samplesCount || 10;
	  const bytes = new Array(samplesCount);
	  const timestamps = new Array(samplesCount);
	  let head = 0;
	  let tail = 0;
	  let firstSampleTS;

	  min = min !== undefined ? min : 1000;

	  return function push(chunkLength) {
	    const now = Date.now();

	    const startedAt = timestamps[tail];

	    if (!firstSampleTS) {
	      firstSampleTS = now;
	    }

	    bytes[head] = chunkLength;
	    timestamps[head] = now;

	    let i = tail;
	    let bytesCount = 0;

	    while (i !== head) {
	      bytesCount += bytes[i++];
	      i = i % samplesCount;
	    }

	    head = (head + 1) % samplesCount;

	    if (head === tail) {
	      tail = (tail + 1) % samplesCount;
	    }

	    if (now - firstSampleTS < min) {
	      return;
	    }

	    const passed = startedAt && now - startedAt;

	    return passed ? Math.round(bytesCount * 1000 / passed) : undefined;
	  };
	}

	const kInternals = Symbol('internals');

	class AxiosTransformStream extends stream__default["default"].Transform{
	  constructor(options) {
	    options = utils$1.toFlatObject(options, {
	      maxRate: 0,
	      chunkSize: 64 * 1024,
	      minChunkSize: 100,
	      timeWindow: 500,
	      ticksRate: 2,
	      samplesCount: 15
	    }, null, (prop, source) => {
	      return !utils$1.isUndefined(source[prop]);
	    });

	    super({
	      readableHighWaterMark: options.chunkSize
	    });

	    const self = this;

	    const internals = this[kInternals] = {
	      length: options.length,
	      timeWindow: options.timeWindow,
	      ticksRate: options.ticksRate,
	      chunkSize: options.chunkSize,
	      maxRate: options.maxRate,
	      minChunkSize: options.minChunkSize,
	      bytesSeen: 0,
	      isCaptured: false,
	      notifiedBytesLoaded: 0,
	      ts: Date.now(),
	      bytes: 0,
	      onReadCallback: null
	    };

	    const _speedometer = speedometer(internals.ticksRate * options.samplesCount, internals.timeWindow);

	    this.on('newListener', event => {
	      if (event === 'progress') {
	        if (!internals.isCaptured) {
	          internals.isCaptured = true;
	        }
	      }
	    });

	    let bytesNotified = 0;

	    internals.updateProgress = throttle(function throttledHandler() {
	      const totalBytes = internals.length;
	      const bytesTransferred = internals.bytesSeen;
	      const progressBytes = bytesTransferred - bytesNotified;
	      if (!progressBytes || self.destroyed) return;

	      const rate = _speedometer(progressBytes);

	      bytesNotified = bytesTransferred;

	      process.nextTick(() => {
	        self.emit('progress', {
	          'loaded': bytesTransferred,
	          'total': totalBytes,
	          'progress': totalBytes ? (bytesTransferred / totalBytes) : undefined,
	          'bytes': progressBytes,
	          'rate': rate ? rate : undefined,
	          'estimated': rate && totalBytes && bytesTransferred <= totalBytes ?
	            (totalBytes - bytesTransferred) / rate : undefined
	        });
	      });
	    }, internals.ticksRate);

	    const onFinish = () => {
	      internals.updateProgress(true);
	    };

	    this.once('end', onFinish);
	    this.once('error', onFinish);
	  }

	  _read(size) {
	    const internals = this[kInternals];

	    if (internals.onReadCallback) {
	      internals.onReadCallback();
	    }

	    return super._read(size);
	  }

	  _transform(chunk, encoding, callback) {
	    const self = this;
	    const internals = this[kInternals];
	    const maxRate = internals.maxRate;

	    const readableHighWaterMark = this.readableHighWaterMark;

	    const timeWindow = internals.timeWindow;

	    const divider = 1000 / timeWindow;
	    const bytesThreshold = (maxRate / divider);
	    const minChunkSize = internals.minChunkSize !== false ? Math.max(internals.minChunkSize, bytesThreshold * 0.01) : 0;

	    function pushChunk(_chunk, _callback) {
	      const bytes = Buffer.byteLength(_chunk);
	      internals.bytesSeen += bytes;
	      internals.bytes += bytes;

	      if (internals.isCaptured) {
	        internals.updateProgress();
	      }

	      if (self.push(_chunk)) {
	        process.nextTick(_callback);
	      } else {
	        internals.onReadCallback = () => {
	          internals.onReadCallback = null;
	          process.nextTick(_callback);
	        };
	      }
	    }

	    const transformChunk = (_chunk, _callback) => {
	      const chunkSize = Buffer.byteLength(_chunk);
	      let chunkRemainder = null;
	      let maxChunkSize = readableHighWaterMark;
	      let bytesLeft;
	      let passed = 0;

	      if (maxRate) {
	        const now = Date.now();

	        if (!internals.ts || (passed = (now - internals.ts)) >= timeWindow) {
	          internals.ts = now;
	          bytesLeft = bytesThreshold - internals.bytes;
	          internals.bytes = bytesLeft < 0 ? -bytesLeft : 0;
	          passed = 0;
	        }

	        bytesLeft = bytesThreshold - internals.bytes;
	      }

	      if (maxRate) {
	        if (bytesLeft <= 0) {
	          // next time window
	          return setTimeout(() => {
	            _callback(null, _chunk);
	          }, timeWindow - passed);
	        }

	        if (bytesLeft < maxChunkSize) {
	          maxChunkSize = bytesLeft;
	        }
	      }

	      if (maxChunkSize && chunkSize > maxChunkSize && (chunkSize - maxChunkSize) > minChunkSize) {
	        chunkRemainder = _chunk.subarray(maxChunkSize);
	        _chunk = _chunk.subarray(0, maxChunkSize);
	      }

	      pushChunk(_chunk, chunkRemainder ? () => {
	        process.nextTick(_callback, null, chunkRemainder);
	      } : _callback);
	    };

	    transformChunk(chunk, function transformNextChunk(err, _chunk) {
	      if (err) {
	        return callback(err);
	      }

	      if (_chunk) {
	        transformChunk(_chunk, transformNextChunk);
	      } else {
	        callback(null);
	      }
	    });
	  }

	  setLength(length) {
	    this[kInternals].length = +length;
	    return this;
	  }
	}

	const AxiosTransformStream$1 = AxiosTransformStream;

	const {asyncIterator} = Symbol;

	const readBlob = async function* (blob) {
	  if (blob.stream) {
	    yield* blob.stream();
	  } else if (blob.arrayBuffer) {
	    yield await blob.arrayBuffer();
	  } else if (blob[asyncIterator]) {
	    yield* blob[asyncIterator]();
	  } else {
	    yield blob;
	  }
	};

	const readBlob$1 = readBlob;

	const BOUNDARY_ALPHABET = utils$1.ALPHABET.ALPHA_DIGIT + '-_';

	const textEncoder = new util.TextEncoder();

	const CRLF = '\r\n';
	const CRLF_BYTES = textEncoder.encode(CRLF);
	const CRLF_BYTES_COUNT = 2;

	class FormDataPart {
	  constructor(name, value) {
	    const {escapeName} = this.constructor;
	    const isStringValue = utils$1.isString(value);

	    let headers = `Content-Disposition: form-data; name="${escapeName(name)}"${
	      !isStringValue && value.name ? `; filename="${escapeName(value.name)}"` : ''
	    }${CRLF}`;

	    if (isStringValue) {
	      value = textEncoder.encode(String(value).replace(/\r?\n|\r\n?/g, CRLF));
	    } else {
	      headers += `Content-Type: ${value.type || "application/octet-stream"}${CRLF}`;
	    }

	    this.headers = textEncoder.encode(headers + CRLF);

	    this.contentLength = isStringValue ? value.byteLength : value.size;

	    this.size = this.headers.byteLength + this.contentLength + CRLF_BYTES_COUNT;

	    this.name = name;
	    this.value = value;
	  }

	  async *encode(){
	    yield this.headers;

	    const {value} = this;

	    if(utils$1.isTypedArray(value)) {
	      yield value;
	    } else {
	      yield* readBlob$1(value);
	    }

	    yield CRLF_BYTES;
	  }

	  static escapeName(name) {
	      return String(name).replace(/[\r\n"]/g, (match) => ({
	        '\r' : '%0D',
	        '\n' : '%0A',
	        '"' : '%22',
	      }[match]));
	  }
	}

	const formDataToStream = (form, headersHandler, options) => {
	  const {
	    tag = 'form-data-boundary',
	    size = 25,
	    boundary = tag + '-' + utils$1.generateString(size, BOUNDARY_ALPHABET)
	  } = options || {};

	  if(!utils$1.isFormData(form)) {
	    throw TypeError('FormData instance required');
	  }

	  if (boundary.length < 1 || boundary.length > 70) {
	    throw Error('boundary must be 10-70 characters long')
	  }

	  const boundaryBytes = textEncoder.encode('--' + boundary + CRLF);
	  const footerBytes = textEncoder.encode('--' + boundary + '--' + CRLF + CRLF);
	  let contentLength = footerBytes.byteLength;

	  const parts = Array.from(form.entries()).map(([name, value]) => {
	    const part = new FormDataPart(name, value);
	    contentLength += part.size;
	    return part;
	  });

	  contentLength += boundaryBytes.byteLength * parts.length;

	  contentLength = utils$1.toFiniteNumber(contentLength);

	  const computedHeaders = {
	    'Content-Type': `multipart/form-data; boundary=${boundary}`
	  };

	  if (Number.isFinite(contentLength)) {
	    computedHeaders['Content-Length'] = contentLength;
	  }

	  headersHandler && headersHandler(computedHeaders);

	  return stream$1.Readable.from((async function *() {
	    for(const part of parts) {
	      yield boundaryBytes;
	      yield* part.encode();
	    }

	    yield footerBytes;
	  })());
	};

	const formDataToStream$1 = formDataToStream;

	class ZlibHeaderTransformStream extends stream__default["default"].Transform {
	  __transform(chunk, encoding, callback) {
	    this.push(chunk);
	    callback();
	  }

	  _transform(chunk, encoding, callback) {
	    if (chunk.length !== 0) {
	      this._transform = this.__transform;

	      // Add Default Compression headers if no zlib headers are present
	      if (chunk[0] !== 120) { // Hex: 78
	        const header = Buffer.alloc(2);
	        header[0] = 120; // Hex: 78
	        header[1] = 156; // Hex: 9C 
	        this.push(header, encoding);
	      }
	    }

	    this.__transform(chunk, encoding, callback);
	  }
	}

	const ZlibHeaderTransformStream$1 = ZlibHeaderTransformStream;

	const callbackify = (fn, reducer) => {
	  return utils$1.isAsyncFn(fn) ? function (...args) {
	    const cb = args.pop();
	    fn.apply(this, args).then((value) => {
	      try {
	        reducer ? cb(null, ...reducer(value)) : cb(null, value);
	      } catch (err) {
	        cb(err);
	      }
	    }, cb);
	  } : fn;
	};

	const callbackify$1 = callbackify;

	const zlibOptions = {
	  flush: zlib__default["default"].constants.Z_SYNC_FLUSH,
	  finishFlush: zlib__default["default"].constants.Z_SYNC_FLUSH
	};

	const brotliOptions = {
	  flush: zlib__default["default"].constants.BROTLI_OPERATION_FLUSH,
	  finishFlush: zlib__default["default"].constants.BROTLI_OPERATION_FLUSH
	};

	const isBrotliSupported = utils$1.isFunction(zlib__default["default"].createBrotliDecompress);

	const {http: httpFollow, https: httpsFollow} = followRedirects__default["default"];

	const isHttps = /https:?/;

	const supportedProtocols = platform.protocols.map(protocol => {
	  return protocol + ':';
	});

	/**
	 * If the proxy or config beforeRedirects functions are defined, call them with the options
	 * object.
	 *
	 * @param {Object<string, any>} options - The options object that was passed to the request.
	 *
	 * @returns {Object<string, any>}
	 */
	function dispatchBeforeRedirect(options, responseDetails) {
	  if (options.beforeRedirects.proxy) {
	    options.beforeRedirects.proxy(options);
	  }
	  if (options.beforeRedirects.config) {
	    options.beforeRedirects.config(options, responseDetails);
	  }
	}

	/**
	 * If the proxy or config afterRedirects functions are defined, call them with the options
	 *
	 * @param {http.ClientRequestArgs} options
	 * @param {AxiosProxyConfig} configProxy configuration from Axios options object
	 * @param {string} location
	 *
	 * @returns {http.ClientRequestArgs}
	 */
	function setProxy(options, configProxy, location) {
	  let proxy = configProxy;
	  if (!proxy && proxy !== false) {
	    const proxyUrl = proxyFromEnv.getProxyForUrl(location);
	    if (proxyUrl) {
	      proxy = new URL(proxyUrl);
	    }
	  }
	  if (proxy) {
	    // Basic proxy authorization
	    if (proxy.username) {
	      proxy.auth = (proxy.username || '') + ':' + (proxy.password || '');
	    }

	    if (proxy.auth) {
	      // Support proxy auth object form
	      if (proxy.auth.username || proxy.auth.password) {
	        proxy.auth = (proxy.auth.username || '') + ':' + (proxy.auth.password || '');
	      }
	      const base64 = Buffer
	        .from(proxy.auth, 'utf8')
	        .toString('base64');
	      options.headers['Proxy-Authorization'] = 'Basic ' + base64;
	    }

	    options.headers.host = options.hostname + (options.port ? ':' + options.port : '');
	    const proxyHost = proxy.hostname || proxy.host;
	    options.hostname = proxyHost;
	    // Replace 'host' since options is not a URL object
	    options.host = proxyHost;
	    options.port = proxy.port;
	    options.path = location;
	    if (proxy.protocol) {
	      options.protocol = proxy.protocol.includes(':') ? proxy.protocol : `${proxy.protocol}:`;
	    }
	  }

	  options.beforeRedirects.proxy = function beforeRedirect(redirectOptions) {
	    // Configure proxy for redirected request, passing the original config proxy to apply
	    // the exact same logic as if the redirected request was performed by axios directly.
	    setProxy(redirectOptions, configProxy, redirectOptions.href);
	  };
	}

	const isHttpAdapterSupported = typeof process !== 'undefined' && utils$1.kindOf(process) === 'process';

	// temporary hotfix

	const wrapAsync = (asyncExecutor) => {
	  return new Promise((resolve, reject) => {
	    let onDone;
	    let isDone;

	    const done = (value, isRejected) => {
	      if (isDone) return;
	      isDone = true;
	      onDone && onDone(value, isRejected);
	    };

	    const _resolve = (value) => {
	      done(value);
	      resolve(value);
	    };

	    const _reject = (reason) => {
	      done(reason, true);
	      reject(reason);
	    };

	    asyncExecutor(_resolve, _reject, (onDoneHandler) => (onDone = onDoneHandler)).catch(_reject);
	  })
	};

	const resolveFamily = ({address, family}) => {
	  if (!utils$1.isString(address)) {
	    throw TypeError('address must be a string');
	  }
	  return ({
	    address,
	    family: family || (address.indexOf('.') < 0 ? 6 : 4)
	  });
	};

	const buildAddressEntry = (address, family) => resolveFamily(utils$1.isObject(address) ? address : {address, family});

	/*eslint consistent-return:0*/
	const httpAdapter = isHttpAdapterSupported && function httpAdapter(config) {
	  return wrapAsync(async function dispatchHttpRequest(resolve, reject, onDone) {
	    let {data, lookup, family} = config;
	    const {responseType, responseEncoding} = config;
	    const method = config.method.toUpperCase();
	    let isDone;
	    let rejected = false;
	    let req;

	    if (lookup) {
	      const _lookup = callbackify$1(lookup, (value) => utils$1.isArray(value) ? value : [value]);
	      // hotfix to support opt.all option which is required for node 20.x
	      lookup = (hostname, opt, cb) => {
	        _lookup(hostname, opt, (err, arg0, arg1) => {
	          if (err) {
	            return cb(err);
	          }

	          const addresses = utils$1.isArray(arg0) ? arg0.map(addr => buildAddressEntry(addr)) : [buildAddressEntry(arg0, arg1)];

	          opt.all ? cb(err, addresses) : cb(err, addresses[0].address, addresses[0].family);
	        });
	      };
	    }

	    // temporary internal emitter until the AxiosRequest class will be implemented
	    const emitter = new EventEmitter__default["default"]();

	    const onFinished = () => {
	      if (config.cancelToken) {
	        config.cancelToken.unsubscribe(abort);
	      }

	      if (config.signal) {
	        config.signal.removeEventListener('abort', abort);
	      }

	      emitter.removeAllListeners();
	    };

	    onDone((value, isRejected) => {
	      isDone = true;
	      if (isRejected) {
	        rejected = true;
	        onFinished();
	      }
	    });

	    function abort(reason) {
	      emitter.emit('abort', !reason || reason.type ? new CanceledError(null, config, req) : reason);
	    }

	    emitter.once('abort', reject);

	    if (config.cancelToken || config.signal) {
	      config.cancelToken && config.cancelToken.subscribe(abort);
	      if (config.signal) {
	        config.signal.aborted ? abort() : config.signal.addEventListener('abort', abort);
	      }
	    }

	    // Parse url
	    const fullPath = buildFullPath(config.baseURL, config.url);
	    const parsed = new URL(fullPath, 'http://localhost');
	    const protocol = parsed.protocol || supportedProtocols[0];

	    if (protocol === 'data:') {
	      let convertedData;

	      if (method !== 'GET') {
	        return settle(resolve, reject, {
	          status: 405,
	          statusText: 'method not allowed',
	          headers: {},
	          config
	        });
	      }

	      try {
	        convertedData = fromDataURI(config.url, responseType === 'blob', {
	          Blob: config.env && config.env.Blob
	        });
	      } catch (err) {
	        throw AxiosError.from(err, AxiosError.ERR_BAD_REQUEST, config);
	      }

	      if (responseType === 'text') {
	        convertedData = convertedData.toString(responseEncoding);

	        if (!responseEncoding || responseEncoding === 'utf8') {
	          convertedData = utils$1.stripBOM(convertedData);
	        }
	      } else if (responseType === 'stream') {
	        convertedData = stream__default["default"].Readable.from(convertedData);
	      }

	      return settle(resolve, reject, {
	        data: convertedData,
	        status: 200,
	        statusText: 'OK',
	        headers: new AxiosHeaders$1(),
	        config
	      });
	    }

	    if (supportedProtocols.indexOf(protocol) === -1) {
	      return reject(new AxiosError(
	        'Unsupported protocol ' + protocol,
	        AxiosError.ERR_BAD_REQUEST,
	        config
	      ));
	    }

	    const headers = AxiosHeaders$1.from(config.headers).normalize();

	    // Set User-Agent (required by some servers)
	    // See https://github.com/axios/axios/issues/69
	    // User-Agent is specified; handle case where no UA header is desired
	    // Only set header if it hasn't been set in config
	    headers.set('User-Agent', 'axios/' + VERSION, false);

	    const onDownloadProgress = config.onDownloadProgress;
	    const onUploadProgress = config.onUploadProgress;
	    const maxRate = config.maxRate;
	    let maxUploadRate = undefined;
	    let maxDownloadRate = undefined;

	    // support for spec compliant FormData objects
	    if (utils$1.isSpecCompliantForm(data)) {
	      const userBoundary = headers.getContentType(/boundary=([-_\w\d]{10,70})/i);

	      data = formDataToStream$1(data, (formHeaders) => {
	        headers.set(formHeaders);
	      }, {
	        tag: `axios-${VERSION}-boundary`,
	        boundary: userBoundary && userBoundary[1] || undefined
	      });
	      // support for https://www.npmjs.com/package/form-data api
	    } else if (utils$1.isFormData(data) && utils$1.isFunction(data.getHeaders)) {
	      headers.set(data.getHeaders());

	      if (!headers.hasContentLength()) {
	        try {
	          const knownLength = await util__default["default"].promisify(data.getLength).call(data);
	          Number.isFinite(knownLength) && knownLength >= 0 && headers.setContentLength(knownLength);
	          /*eslint no-empty:0*/
	        } catch (e) {
	        }
	      }
	    } else if (utils$1.isBlob(data)) {
	      data.size && headers.setContentType(data.type || 'application/octet-stream');
	      headers.setContentLength(data.size || 0);
	      data = stream__default["default"].Readable.from(readBlob$1(data));
	    } else if (data && !utils$1.isStream(data)) {
	      if (Buffer.isBuffer(data)) ; else if (utils$1.isArrayBuffer(data)) {
	        data = Buffer.from(new Uint8Array(data));
	      } else if (utils$1.isString(data)) {
	        data = Buffer.from(data, 'utf-8');
	      } else {
	        return reject(new AxiosError(
	          'Data after transformation must be a string, an ArrayBuffer, a Buffer, or a Stream',
	          AxiosError.ERR_BAD_REQUEST,
	          config
	        ));
	      }

	      // Add Content-Length header if data exists
	      headers.setContentLength(data.length, false);

	      if (config.maxBodyLength > -1 && data.length > config.maxBodyLength) {
	        return reject(new AxiosError(
	          'Request body larger than maxBodyLength limit',
	          AxiosError.ERR_BAD_REQUEST,
	          config
	        ));
	      }
	    }

	    const contentLength = utils$1.toFiniteNumber(headers.getContentLength());

	    if (utils$1.isArray(maxRate)) {
	      maxUploadRate = maxRate[0];
	      maxDownloadRate = maxRate[1];
	    } else {
	      maxUploadRate = maxDownloadRate = maxRate;
	    }

	    if (data && (onUploadProgress || maxUploadRate)) {
	      if (!utils$1.isStream(data)) {
	        data = stream__default["default"].Readable.from(data, {objectMode: false});
	      }

	      data = stream__default["default"].pipeline([data, new AxiosTransformStream$1({
	        length: contentLength,
	        maxRate: utils$1.toFiniteNumber(maxUploadRate)
	      })], utils$1.noop);

	      onUploadProgress && data.on('progress', progress => {
	        onUploadProgress(Object.assign(progress, {
	          upload: true
	        }));
	      });
	    }

	    // HTTP basic authentication
	    let auth = undefined;
	    if (config.auth) {
	      const username = config.auth.username || '';
	      const password = config.auth.password || '';
	      auth = username + ':' + password;
	    }

	    if (!auth && parsed.username) {
	      const urlUsername = parsed.username;
	      const urlPassword = parsed.password;
	      auth = urlUsername + ':' + urlPassword;
	    }

	    auth && headers.delete('authorization');

	    let path;

	    try {
	      path = buildURL(
	        parsed.pathname + parsed.search,
	        config.params,
	        config.paramsSerializer
	      ).replace(/^\?/, '');
	    } catch (err) {
	      const customErr = new Error(err.message);
	      customErr.config = config;
	      customErr.url = config.url;
	      customErr.exists = true;
	      return reject(customErr);
	    }

	    headers.set(
	      'Accept-Encoding',
	      'gzip, compress, deflate' + (isBrotliSupported ? ', br' : ''), false
	      );

	    const options = {
	      path,
	      method: method,
	      headers: headers.toJSON(),
	      agents: { http: config.httpAgent, https: config.httpsAgent },
	      auth,
	      protocol,
	      family,
	      beforeRedirect: dispatchBeforeRedirect,
	      beforeRedirects: {}
	    };

	    // cacheable-lookup integration hotfix
	    !utils$1.isUndefined(lookup) && (options.lookup = lookup);

	    if (config.socketPath) {
	      options.socketPath = config.socketPath;
	    } else {
	      options.hostname = parsed.hostname;
	      options.port = parsed.port;
	      setProxy(options, config.proxy, protocol + '//' + parsed.hostname + (parsed.port ? ':' + parsed.port : '') + options.path);
	    }

	    let transport;
	    const isHttpsRequest = isHttps.test(options.protocol);
	    options.agent = isHttpsRequest ? config.httpsAgent : config.httpAgent;
	    if (config.transport) {
	      transport = config.transport;
	    } else if (config.maxRedirects === 0) {
	      transport = isHttpsRequest ? https__default["default"] : http__default["default"];
	    } else {
	      if (config.maxRedirects) {
	        options.maxRedirects = config.maxRedirects;
	      }
	      if (config.beforeRedirect) {
	        options.beforeRedirects.config = config.beforeRedirect;
	      }
	      transport = isHttpsRequest ? httpsFollow : httpFollow;
	    }

	    if (config.maxBodyLength > -1) {
	      options.maxBodyLength = config.maxBodyLength;
	    } else {
	      // follow-redirects does not skip comparison, so it should always succeed for axios -1 unlimited
	      options.maxBodyLength = Infinity;
	    }

	    if (config.insecureHTTPParser) {
	      options.insecureHTTPParser = config.insecureHTTPParser;
	    }

	    // Create the request
	    req = transport.request(options, function handleResponse(res) {
	      if (req.destroyed) return;

	      const streams = [res];

	      const responseLength = +res.headers['content-length'];

	      if (onDownloadProgress) {
	        const transformStream = new AxiosTransformStream$1({
	          length: utils$1.toFiniteNumber(responseLength),
	          maxRate: utils$1.toFiniteNumber(maxDownloadRate)
	        });

	        onDownloadProgress && transformStream.on('progress', progress => {
	          onDownloadProgress(Object.assign(progress, {
	            download: true
	          }));
	        });

	        streams.push(transformStream);
	      }

	      // decompress the response body transparently if required
	      let responseStream = res;

	      // return the last request in case of redirects
	      const lastRequest = res.req || req;

	      // if decompress disabled we should not decompress
	      if (config.decompress !== false && res.headers['content-encoding']) {
	        // if no content, but headers still say that it is encoded,
	        // remove the header not confuse downstream operations
	        if (method === 'HEAD' || res.statusCode === 204) {
	          delete res.headers['content-encoding'];
	        }

	        switch ((res.headers['content-encoding'] || '').toLowerCase()) {
	        /*eslint default-case:0*/
	        case 'gzip':
	        case 'x-gzip':
	        case 'compress':
	        case 'x-compress':
	          // add the unzipper to the body stream processing pipeline
	          streams.push(zlib__default["default"].createUnzip(zlibOptions));

	          // remove the content-encoding in order to not confuse downstream operations
	          delete res.headers['content-encoding'];
	          break;
	        case 'deflate':
	          streams.push(new ZlibHeaderTransformStream$1());

	          // add the unzipper to the body stream processing pipeline
	          streams.push(zlib__default["default"].createUnzip(zlibOptions));

	          // remove the content-encoding in order to not confuse downstream operations
	          delete res.headers['content-encoding'];
	          break;
	        case 'br':
	          if (isBrotliSupported) {
	            streams.push(zlib__default["default"].createBrotliDecompress(brotliOptions));
	            delete res.headers['content-encoding'];
	          }
	        }
	      }

	      responseStream = streams.length > 1 ? stream__default["default"].pipeline(streams, utils$1.noop) : streams[0];

	      const offListeners = stream__default["default"].finished(responseStream, () => {
	        offListeners();
	        onFinished();
	      });

	      const response = {
	        status: res.statusCode,
	        statusText: res.statusMessage,
	        headers: new AxiosHeaders$1(res.headers),
	        config,
	        request: lastRequest
	      };

	      if (responseType === 'stream') {
	        response.data = responseStream;
	        settle(resolve, reject, response);
	      } else {
	        const responseBuffer = [];
	        let totalResponseBytes = 0;

	        responseStream.on('data', function handleStreamData(chunk) {
	          responseBuffer.push(chunk);
	          totalResponseBytes += chunk.length;

	          // make sure the content length is not over the maxContentLength if specified
	          if (config.maxContentLength > -1 && totalResponseBytes > config.maxContentLength) {
	            // stream.destroy() emit aborted event before calling reject() on Node.js v16
	            rejected = true;
	            responseStream.destroy();
	            reject(new AxiosError('maxContentLength size of ' + config.maxContentLength + ' exceeded',
	              AxiosError.ERR_BAD_RESPONSE, config, lastRequest));
	          }
	        });

	        responseStream.on('aborted', function handlerStreamAborted() {
	          if (rejected) {
	            return;
	          }

	          const err = new AxiosError(
	            'maxContentLength size of ' + config.maxContentLength + ' exceeded',
	            AxiosError.ERR_BAD_RESPONSE,
	            config,
	            lastRequest
	          );
	          responseStream.destroy(err);
	          reject(err);
	        });

	        responseStream.on('error', function handleStreamError(err) {
	          if (req.destroyed) return;
	          reject(AxiosError.from(err, null, config, lastRequest));
	        });

	        responseStream.on('end', function handleStreamEnd() {
	          try {
	            let responseData = responseBuffer.length === 1 ? responseBuffer[0] : Buffer.concat(responseBuffer);
	            if (responseType !== 'arraybuffer') {
	              responseData = responseData.toString(responseEncoding);
	              if (!responseEncoding || responseEncoding === 'utf8') {
	                responseData = utils$1.stripBOM(responseData);
	              }
	            }
	            response.data = responseData;
	          } catch (err) {
	            return reject(AxiosError.from(err, null, config, response.request, response));
	          }
	          settle(resolve, reject, response);
	        });
	      }

	      emitter.once('abort', err => {
	        if (!responseStream.destroyed) {
	          responseStream.emit('error', err);
	          responseStream.destroy();
	        }
	      });
	    });

	    emitter.once('abort', err => {
	      reject(err);
	      req.destroy(err);
	    });

	    // Handle errors
	    req.on('error', function handleRequestError(err) {
	      // @todo remove
	      // if (req.aborted && err.code !== AxiosError.ERR_FR_TOO_MANY_REDIRECTS) return;
	      reject(AxiosError.from(err, null, config, req));
	    });

	    // set tcp keep alive to prevent drop connection by peer
	    req.on('socket', function handleRequestSocket(socket) {
	      // default interval of sending ack packet is 1 minute
	      socket.setKeepAlive(true, 1000 * 60);
	    });

	    // Handle request timeout
	    if (config.timeout) {
	      // This is forcing a int timeout to avoid problems if the `req` interface doesn't handle other types.
	      const timeout = parseInt(config.timeout, 10);

	      if (Number.isNaN(timeout)) {
	        reject(new AxiosError(
	          'error trying to parse `config.timeout` to int',
	          AxiosError.ERR_BAD_OPTION_VALUE,
	          config,
	          req
	        ));

	        return;
	      }

	      // Sometime, the response will be very slow, and does not respond, the connect event will be block by event loop system.
	      // And timer callback will be fired, and abort() will be invoked before connection, then get "socket hang up" and code ECONNRESET.
	      // At this time, if we have a large number of request, nodejs will hang up some socket on background. and the number will up and up.
	      // And then these socket which be hang up will devouring CPU little by little.
	      // ClientRequest.setTimeout will be fired on the specify milliseconds, and can make sure that abort() will be fired after connect.
	      req.setTimeout(timeout, function handleRequestTimeout() {
	        if (isDone) return;
	        let timeoutErrorMessage = config.timeout ? 'timeout of ' + config.timeout + 'ms exceeded' : 'timeout exceeded';
	        const transitional = config.transitional || transitionalDefaults;
	        if (config.timeoutErrorMessage) {
	          timeoutErrorMessage = config.timeoutErrorMessage;
	        }
	        reject(new AxiosError(
	          timeoutErrorMessage,
	          transitional.clarifyTimeoutError ? AxiosError.ETIMEDOUT : AxiosError.ECONNABORTED,
	          config,
	          req
	        ));
	        abort();
	      });
	    }


	    // Send the request
	    if (utils$1.isStream(data)) {
	      let ended = false;
	      let errored = false;

	      data.on('end', () => {
	        ended = true;
	      });

	      data.once('error', err => {
	        errored = true;
	        req.destroy(err);
	      });

	      data.on('close', () => {
	        if (!ended && !errored) {
	          abort(new CanceledError('Request stream has been aborted', config, req));
	        }
	      });

	      data.pipe(req);
	    } else {
	      req.end(data);
	    }
	  });
	};

	const cookies = platform.hasStandardBrowserEnv ?

	  // Standard browser envs support document.cookie
	  {
	    write(name, value, expires, path, domain, secure) {
	      const cookie = [name + '=' + encodeURIComponent(value)];

	      utils$1.isNumber(expires) && cookie.push('expires=' + new Date(expires).toGMTString());

	      utils$1.isString(path) && cookie.push('path=' + path);

	      utils$1.isString(domain) && cookie.push('domain=' + domain);

	      secure === true && cookie.push('secure');

	      document.cookie = cookie.join('; ');
	    },

	    read(name) {
	      const match = document.cookie.match(new RegExp('(^|;\\s*)(' + name + ')=([^;]*)'));
	      return (match ? decodeURIComponent(match[3]) : null);
	    },

	    remove(name) {
	      this.write(name, '', Date.now() - 86400000);
	    }
	  }

	  :

	  // Non-standard browser env (web workers, react-native) lack needed support.
	  {
	    write() {},
	    read() {
	      return null;
	    },
	    remove() {}
	  };

	const isURLSameOrigin = platform.hasStandardBrowserEnv ?

	// Standard browser envs have full support of the APIs needed to test
	// whether the request URL is of the same origin as current location.
	  (function standardBrowserEnv() {
	    const msie = /(msie|trident)/i.test(navigator.userAgent);
	    const urlParsingNode = document.createElement('a');
	    let originURL;

	    /**
	    * Parse a URL to discover its components
	    *
	    * @param {String} url The URL to be parsed
	    * @returns {Object}
	    */
	    function resolveURL(url) {
	      let href = url;

	      if (msie) {
	        // IE needs attribute set twice to normalize properties
	        urlParsingNode.setAttribute('href', href);
	        href = urlParsingNode.href;
	      }

	      urlParsingNode.setAttribute('href', href);

	      // urlParsingNode provides the UrlUtils interface - http://url.spec.whatwg.org/#urlutils
	      return {
	        href: urlParsingNode.href,
	        protocol: urlParsingNode.protocol ? urlParsingNode.protocol.replace(/:$/, '') : '',
	        host: urlParsingNode.host,
	        search: urlParsingNode.search ? urlParsingNode.search.replace(/^\?/, '') : '',
	        hash: urlParsingNode.hash ? urlParsingNode.hash.replace(/^#/, '') : '',
	        hostname: urlParsingNode.hostname,
	        port: urlParsingNode.port,
	        pathname: (urlParsingNode.pathname.charAt(0) === '/') ?
	          urlParsingNode.pathname :
	          '/' + urlParsingNode.pathname
	      };
	    }

	    originURL = resolveURL(window.location.href);

	    /**
	    * Determine if a URL shares the same origin as the current location
	    *
	    * @param {String} requestURL The URL to test
	    * @returns {boolean} True if URL shares the same origin, otherwise false
	    */
	    return function isURLSameOrigin(requestURL) {
	      const parsed = (utils$1.isString(requestURL)) ? resolveURL(requestURL) : requestURL;
	      return (parsed.protocol === originURL.protocol &&
	          parsed.host === originURL.host);
	    };
	  })() :

	  // Non standard browser envs (web workers, react-native) lack needed support.
	  (function nonStandardBrowserEnv() {
	    return function isURLSameOrigin() {
	      return true;
	    };
	  })();

	function progressEventReducer(listener, isDownloadStream) {
	  let bytesNotified = 0;
	  const _speedometer = speedometer(50, 250);

	  return e => {
	    const loaded = e.loaded;
	    const total = e.lengthComputable ? e.total : undefined;
	    const progressBytes = loaded - bytesNotified;
	    const rate = _speedometer(progressBytes);
	    const inRange = loaded <= total;

	    bytesNotified = loaded;

	    const data = {
	      loaded,
	      total,
	      progress: total ? (loaded / total) : undefined,
	      bytes: progressBytes,
	      rate: rate ? rate : undefined,
	      estimated: rate && total && inRange ? (total - loaded) / rate : undefined,
	      event: e
	    };

	    data[isDownloadStream ? 'download' : 'upload'] = true;

	    listener(data);
	  };
	}

	const isXHRAdapterSupported = typeof XMLHttpRequest !== 'undefined';

	const xhrAdapter = isXHRAdapterSupported && function (config) {
	  return new Promise(function dispatchXhrRequest(resolve, reject) {
	    let requestData = config.data;
	    const requestHeaders = AxiosHeaders$1.from(config.headers).normalize();
	    let {responseType, withXSRFToken} = config;
	    let onCanceled;
	    function done() {
	      if (config.cancelToken) {
	        config.cancelToken.unsubscribe(onCanceled);
	      }

	      if (config.signal) {
	        config.signal.removeEventListener('abort', onCanceled);
	      }
	    }

	    let contentType;

	    if (utils$1.isFormData(requestData)) {
	      if (platform.hasStandardBrowserEnv || platform.hasStandardBrowserWebWorkerEnv) {
	        requestHeaders.setContentType(false); // Let the browser set it
	      } else if ((contentType = requestHeaders.getContentType()) !== false) {
	        // fix semicolon duplication issue for ReactNative FormData implementation
	        const [type, ...tokens] = contentType ? contentType.split(';').map(token => token.trim()).filter(Boolean) : [];
	        requestHeaders.setContentType([type || 'multipart/form-data', ...tokens].join('; '));
	      }
	    }

	    let request = new XMLHttpRequest();

	    // HTTP basic authentication
	    if (config.auth) {
	      const username = config.auth.username || '';
	      const password = config.auth.password ? unescape(encodeURIComponent(config.auth.password)) : '';
	      requestHeaders.set('Authorization', 'Basic ' + btoa(username + ':' + password));
	    }

	    const fullPath = buildFullPath(config.baseURL, config.url);

	    request.open(config.method.toUpperCase(), buildURL(fullPath, config.params, config.paramsSerializer), true);

	    // Set the request timeout in MS
	    request.timeout = config.timeout;

	    function onloadend() {
	      if (!request) {
	        return;
	      }
	      // Prepare the response
	      const responseHeaders = AxiosHeaders$1.from(
	        'getAllResponseHeaders' in request && request.getAllResponseHeaders()
	      );
	      const responseData = !responseType || responseType === 'text' || responseType === 'json' ?
	        request.responseText : request.response;
	      const response = {
	        data: responseData,
	        status: request.status,
	        statusText: request.statusText,
	        headers: responseHeaders,
	        config,
	        request
	      };

	      settle(function _resolve(value) {
	        resolve(value);
	        done();
	      }, function _reject(err) {
	        reject(err);
	        done();
	      }, response);

	      // Clean up request
	      request = null;
	    }

	    if ('onloadend' in request) {
	      // Use onloadend if available
	      request.onloadend = onloadend;
	    } else {
	      // Listen for ready state to emulate onloadend
	      request.onreadystatechange = function handleLoad() {
	        if (!request || request.readyState !== 4) {
	          return;
	        }

	        // The request errored out and we didn't get a response, this will be
	        // handled by onerror instead
	        // With one exception: request that using file: protocol, most browsers
	        // will return status as 0 even though it's a successful request
	        if (request.status === 0 && !(request.responseURL && request.responseURL.indexOf('file:') === 0)) {
	          return;
	        }
	        // readystate handler is calling before onerror or ontimeout handlers,
	        // so we should call onloadend on the next 'tick'
	        setTimeout(onloadend);
	      };
	    }

	    // Handle browser request cancellation (as opposed to a manual cancellation)
	    request.onabort = function handleAbort() {
	      if (!request) {
	        return;
	      }

	      reject(new AxiosError('Request aborted', AxiosError.ECONNABORTED, config, request));

	      // Clean up request
	      request = null;
	    };

	    // Handle low level network errors
	    request.onerror = function handleError() {
	      // Real errors are hidden from us by the browser
	      // onerror should only fire if it's a network error
	      reject(new AxiosError('Network Error', AxiosError.ERR_NETWORK, config, request));

	      // Clean up request
	      request = null;
	    };

	    // Handle timeout
	    request.ontimeout = function handleTimeout() {
	      let timeoutErrorMessage = config.timeout ? 'timeout of ' + config.timeout + 'ms exceeded' : 'timeout exceeded';
	      const transitional = config.transitional || transitionalDefaults;
	      if (config.timeoutErrorMessage) {
	        timeoutErrorMessage = config.timeoutErrorMessage;
	      }
	      reject(new AxiosError(
	        timeoutErrorMessage,
	        transitional.clarifyTimeoutError ? AxiosError.ETIMEDOUT : AxiosError.ECONNABORTED,
	        config,
	        request));

	      // Clean up request
	      request = null;
	    };

	    // Add xsrf header
	    // This is only done if running in a standard browser environment.
	    // Specifically not if we're in a web worker, or react-native.
	    if(platform.hasStandardBrowserEnv) {
	      withXSRFToken && utils$1.isFunction(withXSRFToken) && (withXSRFToken = withXSRFToken(config));

	      if (withXSRFToken || (withXSRFToken !== false && isURLSameOrigin(fullPath))) {
	        // Add xsrf header
	        const xsrfValue = config.xsrfHeaderName && config.xsrfCookieName && cookies.read(config.xsrfCookieName);

	        if (xsrfValue) {
	          requestHeaders.set(config.xsrfHeaderName, xsrfValue);
	        }
	      }
	    }

	    // Remove Content-Type if data is undefined
	    requestData === undefined && requestHeaders.setContentType(null);

	    // Add headers to the request
	    if ('setRequestHeader' in request) {
	      utils$1.forEach(requestHeaders.toJSON(), function setRequestHeader(val, key) {
	        request.setRequestHeader(key, val);
	      });
	    }

	    // Add withCredentials to request if needed
	    if (!utils$1.isUndefined(config.withCredentials)) {
	      request.withCredentials = !!config.withCredentials;
	    }

	    // Add responseType to request if needed
	    if (responseType && responseType !== 'json') {
	      request.responseType = config.responseType;
	    }

	    // Handle progress if needed
	    if (typeof config.onDownloadProgress === 'function') {
	      request.addEventListener('progress', progressEventReducer(config.onDownloadProgress, true));
	    }

	    // Not all browsers support upload events
	    if (typeof config.onUploadProgress === 'function' && request.upload) {
	      request.upload.addEventListener('progress', progressEventReducer(config.onUploadProgress));
	    }

	    if (config.cancelToken || config.signal) {
	      // Handle cancellation
	      // eslint-disable-next-line func-names
	      onCanceled = cancel => {
	        if (!request) {
	          return;
	        }
	        reject(!cancel || cancel.type ? new CanceledError(null, config, request) : cancel);
	        request.abort();
	        request = null;
	      };

	      config.cancelToken && config.cancelToken.subscribe(onCanceled);
	      if (config.signal) {
	        config.signal.aborted ? onCanceled() : config.signal.addEventListener('abort', onCanceled);
	      }
	    }

	    const protocol = parseProtocol(fullPath);

	    if (protocol && platform.protocols.indexOf(protocol) === -1) {
	      reject(new AxiosError('Unsupported protocol ' + protocol + ':', AxiosError.ERR_BAD_REQUEST, config));
	      return;
	    }


	    // Send the request
	    request.send(requestData || null);
	  });
	};

	const knownAdapters = {
	  http: httpAdapter,
	  xhr: xhrAdapter
	};

	utils$1.forEach(knownAdapters, (fn, value) => {
	  if (fn) {
	    try {
	      Object.defineProperty(fn, 'name', {value});
	    } catch (e) {
	      // eslint-disable-next-line no-empty
	    }
	    Object.defineProperty(fn, 'adapterName', {value});
	  }
	});

	const renderReason = (reason) => `- ${reason}`;

	const isResolvedHandle = (adapter) => utils$1.isFunction(adapter) || adapter === null || adapter === false;

	const adapters = {
	  getAdapter: (adapters) => {
	    adapters = utils$1.isArray(adapters) ? adapters : [adapters];

	    const {length} = adapters;
	    let nameOrAdapter;
	    let adapter;

	    const rejectedReasons = {};

	    for (let i = 0; i < length; i++) {
	      nameOrAdapter = adapters[i];
	      let id;

	      adapter = nameOrAdapter;

	      if (!isResolvedHandle(nameOrAdapter)) {
	        adapter = knownAdapters[(id = String(nameOrAdapter)).toLowerCase()];

	        if (adapter === undefined) {
	          throw new AxiosError(`Unknown adapter '${id}'`);
	        }
	      }

	      if (adapter) {
	        break;
	      }

	      rejectedReasons[id || '#' + i] = adapter;
	    }

	    if (!adapter) {

	      const reasons = Object.entries(rejectedReasons)
	        .map(([id, state]) => `adapter ${id} ` +
	          (state === false ? 'is not supported by the environment' : 'is not available in the build')
	        );

	      let s = length ?
	        (reasons.length > 1 ? 'since :\n' + reasons.map(renderReason).join('\n') : ' ' + renderReason(reasons[0])) :
	        'as no adapter specified';

	      throw new AxiosError(
	        `There is no suitable adapter to dispatch the request ` + s,
	        'ERR_NOT_SUPPORT'
	      );
	    }

	    return adapter;
	  },
	  adapters: knownAdapters
	};

	/**
	 * Throws a `CanceledError` if cancellation has been requested.
	 *
	 * @param {Object} config The config that is to be used for the request
	 *
	 * @returns {void}
	 */
	function throwIfCancellationRequested(config) {
	  if (config.cancelToken) {
	    config.cancelToken.throwIfRequested();
	  }

	  if (config.signal && config.signal.aborted) {
	    throw new CanceledError(null, config);
	  }
	}

	/**
	 * Dispatch a request to the server using the configured adapter.
	 *
	 * @param {object} config The config that is to be used for the request
	 *
	 * @returns {Promise} The Promise to be fulfilled
	 */
	function dispatchRequest(config) {
	  throwIfCancellationRequested(config);

	  config.headers = AxiosHeaders$1.from(config.headers);

	  // Transform request data
	  config.data = transformData.call(
	    config,
	    config.transformRequest
	  );

	  if (['post', 'put', 'patch'].indexOf(config.method) !== -1) {
	    config.headers.setContentType('application/x-www-form-urlencoded', false);
	  }

	  const adapter = adapters.getAdapter(config.adapter || defaults$1.adapter);

	  return adapter(config).then(function onAdapterResolution(response) {
	    throwIfCancellationRequested(config);

	    // Transform response data
	    response.data = transformData.call(
	      config,
	      config.transformResponse,
	      response
	    );

	    response.headers = AxiosHeaders$1.from(response.headers);

	    return response;
	  }, function onAdapterRejection(reason) {
	    if (!isCancel(reason)) {
	      throwIfCancellationRequested(config);

	      // Transform response data
	      if (reason && reason.response) {
	        reason.response.data = transformData.call(
	          config,
	          config.transformResponse,
	          reason.response
	        );
	        reason.response.headers = AxiosHeaders$1.from(reason.response.headers);
	      }
	    }

	    return Promise.reject(reason);
	  });
	}

	const headersToObject = (thing) => thing instanceof AxiosHeaders$1 ? thing.toJSON() : thing;

	/**
	 * Config-specific merge-function which creates a new config-object
	 * by merging two configuration objects together.
	 *
	 * @param {Object} config1
	 * @param {Object} config2
	 *
	 * @returns {Object} New object resulting from merging config2 to config1
	 */
	function mergeConfig(config1, config2) {
	  // eslint-disable-next-line no-param-reassign
	  config2 = config2 || {};
	  const config = {};

	  function getMergedValue(target, source, caseless) {
	    if (utils$1.isPlainObject(target) && utils$1.isPlainObject(source)) {
	      return utils$1.merge.call({caseless}, target, source);
	    } else if (utils$1.isPlainObject(source)) {
	      return utils$1.merge({}, source);
	    } else if (utils$1.isArray(source)) {
	      return source.slice();
	    }
	    return source;
	  }

	  // eslint-disable-next-line consistent-return
	  function mergeDeepProperties(a, b, caseless) {
	    if (!utils$1.isUndefined(b)) {
	      return getMergedValue(a, b, caseless);
	    } else if (!utils$1.isUndefined(a)) {
	      return getMergedValue(undefined, a, caseless);
	    }
	  }

	  // eslint-disable-next-line consistent-return
	  function valueFromConfig2(a, b) {
	    if (!utils$1.isUndefined(b)) {
	      return getMergedValue(undefined, b);
	    }
	  }

	  // eslint-disable-next-line consistent-return
	  function defaultToConfig2(a, b) {
	    if (!utils$1.isUndefined(b)) {
	      return getMergedValue(undefined, b);
	    } else if (!utils$1.isUndefined(a)) {
	      return getMergedValue(undefined, a);
	    }
	  }

	  // eslint-disable-next-line consistent-return
	  function mergeDirectKeys(a, b, prop) {
	    if (prop in config2) {
	      return getMergedValue(a, b);
	    } else if (prop in config1) {
	      return getMergedValue(undefined, a);
	    }
	  }

	  const mergeMap = {
	    url: valueFromConfig2,
	    method: valueFromConfig2,
	    data: valueFromConfig2,
	    baseURL: defaultToConfig2,
	    transformRequest: defaultToConfig2,
	    transformResponse: defaultToConfig2,
	    paramsSerializer: defaultToConfig2,
	    timeout: defaultToConfig2,
	    timeoutMessage: defaultToConfig2,
	    withCredentials: defaultToConfig2,
	    withXSRFToken: defaultToConfig2,
	    adapter: defaultToConfig2,
	    responseType: defaultToConfig2,
	    xsrfCookieName: defaultToConfig2,
	    xsrfHeaderName: defaultToConfig2,
	    onUploadProgress: defaultToConfig2,
	    onDownloadProgress: defaultToConfig2,
	    decompress: defaultToConfig2,
	    maxContentLength: defaultToConfig2,
	    maxBodyLength: defaultToConfig2,
	    beforeRedirect: defaultToConfig2,
	    transport: defaultToConfig2,
	    httpAgent: defaultToConfig2,
	    httpsAgent: defaultToConfig2,
	    cancelToken: defaultToConfig2,
	    socketPath: defaultToConfig2,
	    responseEncoding: defaultToConfig2,
	    validateStatus: mergeDirectKeys,
	    headers: (a, b) => mergeDeepProperties(headersToObject(a), headersToObject(b), true)
	  };

	  utils$1.forEach(Object.keys(Object.assign({}, config1, config2)), function computeConfigValue(prop) {
	    const merge = mergeMap[prop] || mergeDeepProperties;
	    const configValue = merge(config1[prop], config2[prop], prop);
	    (utils$1.isUndefined(configValue) && merge !== mergeDirectKeys) || (config[prop] = configValue);
	  });

	  return config;
	}

	const validators$1 = {};

	// eslint-disable-next-line func-names
	['object', 'boolean', 'number', 'function', 'string', 'symbol'].forEach((type, i) => {
	  validators$1[type] = function validator(thing) {
	    return typeof thing === type || 'a' + (i < 1 ? 'n ' : ' ') + type;
	  };
	});

	const deprecatedWarnings = {};

	/**
	 * Transitional option validator
	 *
	 * @param {function|boolean?} validator - set to false if the transitional option has been removed
	 * @param {string?} version - deprecated version / removed since version
	 * @param {string?} message - some message with additional info
	 *
	 * @returns {function}
	 */
	validators$1.transitional = function transitional(validator, version, message) {
	  function formatMessage(opt, desc) {
	    return '[Axios v' + VERSION + '] Transitional option \'' + opt + '\'' + desc + (message ? '. ' + message : '');
	  }

	  // eslint-disable-next-line func-names
	  return (value, opt, opts) => {
	    if (validator === false) {
	      throw new AxiosError(
	        formatMessage(opt, ' has been removed' + (version ? ' in ' + version : '')),
	        AxiosError.ERR_DEPRECATED
	      );
	    }

	    if (version && !deprecatedWarnings[opt]) {
	      deprecatedWarnings[opt] = true;
	      // eslint-disable-next-line no-console
	      console.warn(
	        formatMessage(
	          opt,
	          ' has been deprecated since v' + version + ' and will be removed in the near future'
	        )
	      );
	    }

	    return validator ? validator(value, opt, opts) : true;
	  };
	};

	/**
	 * Assert object's properties type
	 *
	 * @param {object} options
	 * @param {object} schema
	 * @param {boolean?} allowUnknown
	 *
	 * @returns {object}
	 */

	function assertOptions(options, schema, allowUnknown) {
	  if (typeof options !== 'object') {
	    throw new AxiosError('options must be an object', AxiosError.ERR_BAD_OPTION_VALUE);
	  }
	  const keys = Object.keys(options);
	  let i = keys.length;
	  while (i-- > 0) {
	    const opt = keys[i];
	    const validator = schema[opt];
	    if (validator) {
	      const value = options[opt];
	      const result = value === undefined || validator(value, opt, options);
	      if (result !== true) {
	        throw new AxiosError('option ' + opt + ' must be ' + result, AxiosError.ERR_BAD_OPTION_VALUE);
	      }
	      continue;
	    }
	    if (allowUnknown !== true) {
	      throw new AxiosError('Unknown option ' + opt, AxiosError.ERR_BAD_OPTION);
	    }
	  }
	}

	const validator = {
	  assertOptions,
	  validators: validators$1
	};

	const validators = validator.validators;

	/**
	 * Create a new instance of Axios
	 *
	 * @param {Object} instanceConfig The default config for the instance
	 *
	 * @return {Axios} A new instance of Axios
	 */
	class Axios {
	  constructor(instanceConfig) {
	    this.defaults = instanceConfig;
	    this.interceptors = {
	      request: new InterceptorManager$1(),
	      response: new InterceptorManager$1()
	    };
	  }

	  /**
	   * Dispatch a request
	   *
	   * @param {String|Object} configOrUrl The config specific for this request (merged with this.defaults)
	   * @param {?Object} config
	   *
	   * @returns {Promise} The Promise to be fulfilled
	   */
	  async request(configOrUrl, config) {
	    try {
	      return await this._request(configOrUrl, config);
	    } catch (err) {
	      if (err instanceof Error) {
	        let dummy;

	        Error.captureStackTrace ? Error.captureStackTrace(dummy = {}) : (dummy = new Error());

	        // slice off the Error: ... line
	        const stack = dummy.stack ? dummy.stack.replace(/^.+\n/, '') : '';

	        if (!err.stack) {
	          err.stack = stack;
	          // match without the 2 top stack lines
	        } else if (stack && !String(err.stack).endsWith(stack.replace(/^.+\n.+\n/, ''))) {
	          err.stack += '\n' + stack;
	        }
	      }

	      throw err;
	    }
	  }

	  _request(configOrUrl, config) {
	    /*eslint no-param-reassign:0*/
	    // Allow for axios('example/url'[, config]) a la fetch API
	    if (typeof configOrUrl === 'string') {
	      config = config || {};
	      config.url = configOrUrl;
	    } else {
	      config = configOrUrl || {};
	    }

	    config = mergeConfig(this.defaults, config);

	    const {transitional, paramsSerializer, headers} = config;

	    if (transitional !== undefined) {
	      validator.assertOptions(transitional, {
	        silentJSONParsing: validators.transitional(validators.boolean),
	        forcedJSONParsing: validators.transitional(validators.boolean),
	        clarifyTimeoutError: validators.transitional(validators.boolean)
	      }, false);
	    }

	    if (paramsSerializer != null) {
	      if (utils$1.isFunction(paramsSerializer)) {
	        config.paramsSerializer = {
	          serialize: paramsSerializer
	        };
	      } else {
	        validator.assertOptions(paramsSerializer, {
	          encode: validators.function,
	          serialize: validators.function
	        }, true);
	      }
	    }

	    // Set config.method
	    config.method = (config.method || this.defaults.method || 'get').toLowerCase();

	    // Flatten headers
	    let contextHeaders = headers && utils$1.merge(
	      headers.common,
	      headers[config.method]
	    );

	    headers && utils$1.forEach(
	      ['delete', 'get', 'head', 'post', 'put', 'patch', 'common'],
	      (method) => {
	        delete headers[method];
	      }
	    );

	    config.headers = AxiosHeaders$1.concat(contextHeaders, headers);

	    // filter out skipped interceptors
	    const requestInterceptorChain = [];
	    let synchronousRequestInterceptors = true;
	    this.interceptors.request.forEach(function unshiftRequestInterceptors(interceptor) {
	      if (typeof interceptor.runWhen === 'function' && interceptor.runWhen(config) === false) {
	        return;
	      }

	      synchronousRequestInterceptors = synchronousRequestInterceptors && interceptor.synchronous;

	      requestInterceptorChain.unshift(interceptor.fulfilled, interceptor.rejected);
	    });

	    const responseInterceptorChain = [];
	    this.interceptors.response.forEach(function pushResponseInterceptors(interceptor) {
	      responseInterceptorChain.push(interceptor.fulfilled, interceptor.rejected);
	    });

	    let promise;
	    let i = 0;
	    let len;

	    if (!synchronousRequestInterceptors) {
	      const chain = [dispatchRequest.bind(this), undefined];
	      chain.unshift.apply(chain, requestInterceptorChain);
	      chain.push.apply(chain, responseInterceptorChain);
	      len = chain.length;

	      promise = Promise.resolve(config);

	      while (i < len) {
	        promise = promise.then(chain[i++], chain[i++]);
	      }

	      return promise;
	    }

	    len = requestInterceptorChain.length;

	    let newConfig = config;

	    i = 0;

	    while (i < len) {
	      const onFulfilled = requestInterceptorChain[i++];
	      const onRejected = requestInterceptorChain[i++];
	      try {
	        newConfig = onFulfilled(newConfig);
	      } catch (error) {
	        onRejected.call(this, error);
	        break;
	      }
	    }

	    try {
	      promise = dispatchRequest.call(this, newConfig);
	    } catch (error) {
	      return Promise.reject(error);
	    }

	    i = 0;
	    len = responseInterceptorChain.length;

	    while (i < len) {
	      promise = promise.then(responseInterceptorChain[i++], responseInterceptorChain[i++]);
	    }

	    return promise;
	  }

	  getUri(config) {
	    config = mergeConfig(this.defaults, config);
	    const fullPath = buildFullPath(config.baseURL, config.url);
	    return buildURL(fullPath, config.params, config.paramsSerializer);
	  }
	}

	// Provide aliases for supported request methods
	utils$1.forEach(['delete', 'get', 'head', 'options'], function forEachMethodNoData(method) {
	  /*eslint func-names:0*/
	  Axios.prototype[method] = function(url, config) {
	    return this.request(mergeConfig(config || {}, {
	      method,
	      url,
	      data: (config || {}).data
	    }));
	  };
	});

	utils$1.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {
	  /*eslint func-names:0*/

	  function generateHTTPMethod(isForm) {
	    return function httpMethod(url, data, config) {
	      return this.request(mergeConfig(config || {}, {
	        method,
	        headers: isForm ? {
	          'Content-Type': 'multipart/form-data'
	        } : {},
	        url,
	        data
	      }));
	    };
	  }

	  Axios.prototype[method] = generateHTTPMethod();

	  Axios.prototype[method + 'Form'] = generateHTTPMethod(true);
	});

	const Axios$1 = Axios;

	/**
	 * A `CancelToken` is an object that can be used to request cancellation of an operation.
	 *
	 * @param {Function} executor The executor function.
	 *
	 * @returns {CancelToken}
	 */
	class CancelToken {
	  constructor(executor) {
	    if (typeof executor !== 'function') {
	      throw new TypeError('executor must be a function.');
	    }

	    let resolvePromise;

	    this.promise = new Promise(function promiseExecutor(resolve) {
	      resolvePromise = resolve;
	    });

	    const token = this;

	    // eslint-disable-next-line func-names
	    this.promise.then(cancel => {
	      if (!token._listeners) return;

	      let i = token._listeners.length;

	      while (i-- > 0) {
	        token._listeners[i](cancel);
	      }
	      token._listeners = null;
	    });

	    // eslint-disable-next-line func-names
	    this.promise.then = onfulfilled => {
	      let _resolve;
	      // eslint-disable-next-line func-names
	      const promise = new Promise(resolve => {
	        token.subscribe(resolve);
	        _resolve = resolve;
	      }).then(onfulfilled);

	      promise.cancel = function reject() {
	        token.unsubscribe(_resolve);
	      };

	      return promise;
	    };

	    executor(function cancel(message, config, request) {
	      if (token.reason) {
	        // Cancellation has already been requested
	        return;
	      }

	      token.reason = new CanceledError(message, config, request);
	      resolvePromise(token.reason);
	    });
	  }

	  /**
	   * Throws a `CanceledError` if cancellation has been requested.
	   */
	  throwIfRequested() {
	    if (this.reason) {
	      throw this.reason;
	    }
	  }

	  /**
	   * Subscribe to the cancel signal
	   */

	  subscribe(listener) {
	    if (this.reason) {
	      listener(this.reason);
	      return;
	    }

	    if (this._listeners) {
	      this._listeners.push(listener);
	    } else {
	      this._listeners = [listener];
	    }
	  }

	  /**
	   * Unsubscribe from the cancel signal
	   */

	  unsubscribe(listener) {
	    if (!this._listeners) {
	      return;
	    }
	    const index = this._listeners.indexOf(listener);
	    if (index !== -1) {
	      this._listeners.splice(index, 1);
	    }
	  }

	  /**
	   * Returns an object that contains a new `CancelToken` and a function that, when called,
	   * cancels the `CancelToken`.
	   */
	  static source() {
	    let cancel;
	    const token = new CancelToken(function executor(c) {
	      cancel = c;
	    });
	    return {
	      token,
	      cancel
	    };
	  }
	}

	const CancelToken$1 = CancelToken;

	/**
	 * Syntactic sugar for invoking a function and expanding an array for arguments.
	 *
	 * Common use case would be to use `Function.prototype.apply`.
	 *
	 *  ```js
	 *  function f(x, y, z) {}
	 *  var args = [1, 2, 3];
	 *  f.apply(null, args);
	 *  ```
	 *
	 * With `spread` this example can be re-written.
	 *
	 *  ```js
	 *  spread(function(x, y, z) {})([1, 2, 3]);
	 *  ```
	 *
	 * @param {Function} callback
	 *
	 * @returns {Function}
	 */
	function spread(callback) {
	  return function wrap(arr) {
	    return callback.apply(null, arr);
	  };
	}

	/**
	 * Determines whether the payload is an error thrown by Axios
	 *
	 * @param {*} payload The value to test
	 *
	 * @returns {boolean} True if the payload is an error thrown by Axios, otherwise false
	 */
	function isAxiosError(payload) {
	  return utils$1.isObject(payload) && (payload.isAxiosError === true);
	}

	const HttpStatusCode = {
	  Continue: 100,
	  SwitchingProtocols: 101,
	  Processing: 102,
	  EarlyHints: 103,
	  Ok: 200,
	  Created: 201,
	  Accepted: 202,
	  NonAuthoritativeInformation: 203,
	  NoContent: 204,
	  ResetContent: 205,
	  PartialContent: 206,
	  MultiStatus: 207,
	  AlreadyReported: 208,
	  ImUsed: 226,
	  MultipleChoices: 300,
	  MovedPermanently: 301,
	  Found: 302,
	  SeeOther: 303,
	  NotModified: 304,
	  UseProxy: 305,
	  Unused: 306,
	  TemporaryRedirect: 307,
	  PermanentRedirect: 308,
	  BadRequest: 400,
	  Unauthorized: 401,
	  PaymentRequired: 402,
	  Forbidden: 403,
	  NotFound: 404,
	  MethodNotAllowed: 405,
	  NotAcceptable: 406,
	  ProxyAuthenticationRequired: 407,
	  RequestTimeout: 408,
	  Conflict: 409,
	  Gone: 410,
	  LengthRequired: 411,
	  PreconditionFailed: 412,
	  PayloadTooLarge: 413,
	  UriTooLong: 414,
	  UnsupportedMediaType: 415,
	  RangeNotSatisfiable: 416,
	  ExpectationFailed: 417,
	  ImATeapot: 418,
	  MisdirectedRequest: 421,
	  UnprocessableEntity: 422,
	  Locked: 423,
	  FailedDependency: 424,
	  TooEarly: 425,
	  UpgradeRequired: 426,
	  PreconditionRequired: 428,
	  TooManyRequests: 429,
	  RequestHeaderFieldsTooLarge: 431,
	  UnavailableForLegalReasons: 451,
	  InternalServerError: 500,
	  NotImplemented: 501,
	  BadGateway: 502,
	  ServiceUnavailable: 503,
	  GatewayTimeout: 504,
	  HttpVersionNotSupported: 505,
	  VariantAlsoNegotiates: 506,
	  InsufficientStorage: 507,
	  LoopDetected: 508,
	  NotExtended: 510,
	  NetworkAuthenticationRequired: 511,
	};

	Object.entries(HttpStatusCode).forEach(([key, value]) => {
	  HttpStatusCode[value] = key;
	});

	const HttpStatusCode$1 = HttpStatusCode;

	/**
	 * Create an instance of Axios
	 *
	 * @param {Object} defaultConfig The default config for the instance
	 *
	 * @returns {Axios} A new instance of Axios
	 */
	function createInstance(defaultConfig) {
	  const context = new Axios$1(defaultConfig);
	  const instance = bind(Axios$1.prototype.request, context);

	  // Copy axios.prototype to instance
	  utils$1.extend(instance, Axios$1.prototype, context, {allOwnKeys: true});

	  // Copy context to instance
	  utils$1.extend(instance, context, null, {allOwnKeys: true});

	  // Factory for creating new instances
	  instance.create = function create(instanceConfig) {
	    return createInstance(mergeConfig(defaultConfig, instanceConfig));
	  };

	  return instance;
	}

	// Create the default instance to be exported
	const axios = createInstance(defaults$1);

	// Expose Axios class to allow class inheritance
	axios.Axios = Axios$1;

	// Expose Cancel & CancelToken
	axios.CanceledError = CanceledError;
	axios.CancelToken = CancelToken$1;
	axios.isCancel = isCancel;
	axios.VERSION = VERSION;
	axios.toFormData = toFormData;

	// Expose AxiosError class
	axios.AxiosError = AxiosError;

	// alias for CanceledError for backward compatibility
	axios.Cancel = axios.CanceledError;

	// Expose all/spread
	axios.all = function all(promises) {
	  return Promise.all(promises);
	};

	axios.spread = spread;

	// Expose isAxiosError
	axios.isAxiosError = isAxiosError;

	// Expose mergeConfig
	axios.mergeConfig = mergeConfig;

	axios.AxiosHeaders = AxiosHeaders$1;

	axios.formToJSON = thing => formDataToJSON(utils$1.isHTMLForm(thing) ? new FormData(thing) : thing);

	axios.getAdapter = adapters.getAdapter;

	axios.HttpStatusCode = HttpStatusCode$1;

	axios.default = axios;

	axios_1 = axios;
	
	return axios_1;
}

var common$2 = {};

var base$1 = {};

var hasRequiredBase$1;

function requireBase$1 () {
	if (hasRequiredBase$1) return base$1;
	hasRequiredBase$1 = 1;
	(function (exports) {
		/* tslint:disable */
		/* eslint-disable */
		/**
		 * IdentityNow Beta API
		 * Use these APIs to interact with the IdentityNow platform to achieve repeatable, automated processes with greater scalability. These APIs are in beta and are subject to change. We encourage you to join the SailPoint Developer Community forum at https://developer.sailpoint.com/discuss to connect with other developers using our APIs.
		 *
		 * The version of the OpenAPI document: 3.1.0-beta
		 *
		 *
		 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
		 * https://openapi-generator.tech
		 * Do not edit the class manually.
		 */
		var __extends = (commonjsGlobal && commonjsGlobal.__extends) || (function () {
		    var extendStatics = function (d, b) {
		        extendStatics = Object.setPrototypeOf ||
		            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
		            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
		        return extendStatics(d, b);
		    };
		    return function (d, b) {
		        if (typeof b !== "function" && b !== null)
		            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
		        extendStatics(d, b);
		        function __() { this.constructor = d; }
		        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
		    };
		})();
		var __importDefault = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
		    return (mod && mod.__esModule) ? mod : { "default": mod };
		};
		Object.defineProperty(exports, "__esModule", { value: true });
		exports.RequiredError = exports.BaseAPI = exports.COLLECTION_FORMATS = exports.BASE_PATH = void 0;
		// Some imports not used depending on template conditions
		// @ts-ignore
		var axios_1 = __importDefault(requireAxios());
		exports.BASE_PATH = "https://sailpoint.api.identitynow.com/beta".replace(/\/+$/, "");
		/**
		 *
		 * @export
		 */
		exports.COLLECTION_FORMATS = {
		    csv: ",",
		    ssv: " ",
		    tsv: "\t",
		    pipes: "|",
		};
		/**
		 *
		 * @export
		 * @class BaseAPI
		 */
		var BaseAPI = /** @class */ (function () {
		    function BaseAPI(configuration, basePath, axios) {
		        if (basePath === void 0) { basePath = exports.BASE_PATH; }
		        if (axios === void 0) { axios = axios_1.default; }
		        this.basePath = basePath;
		        this.axios = axios;
		        if (configuration) {
		            this.configuration = configuration;
		            this.basePath = configuration.basePath + "/beta" || this.basePath;
		        }
		    }
		    return BaseAPI;
		}());
		exports.BaseAPI = BaseAPI;
		/**
		 *
		 * @export
		 * @class RequiredError
		 * @extends {Error}
		 */
		var RequiredError = /** @class */ (function (_super) {
		    __extends(RequiredError, _super);
		    function RequiredError(field, msg) {
		        var _this = _super.call(this, msg) || this;
		        _this.field = field;
		        _this.name = "RequiredError";
		        return _this;
		    }
		    return RequiredError;
		}(Error));
		exports.RequiredError = RequiredError;
		
	} (base$1));
	return base$1;
}

var axiosRetry = {exports: {}};

var cjs = {};

var interopRequireDefault = {exports: {}};

var hasRequiredInteropRequireDefault;

function requireInteropRequireDefault () {
	if (hasRequiredInteropRequireDefault) return interopRequireDefault.exports;
	hasRequiredInteropRequireDefault = 1;
	(function (module) {
		function _interopRequireDefault(obj) {
		  return obj && obj.__esModule ? obj : {
		    "default": obj
		  };
		}
		module.exports = _interopRequireDefault, module.exports.__esModule = true, module.exports["default"] = module.exports; 
	} (interopRequireDefault));
	return interopRequireDefault.exports;
}

var regeneratorRuntime$1 = {exports: {}};

var _typeof = {exports: {}};

var hasRequired_typeof;

function require_typeof () {
	if (hasRequired_typeof) return _typeof.exports;
	hasRequired_typeof = 1;
	(function (module) {
		function _typeof(o) {
		  "@babel/helpers - typeof";

		  return (module.exports = _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
		    return typeof o;
		  } : function (o) {
		    return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
		  }, module.exports.__esModule = true, module.exports["default"] = module.exports), _typeof(o);
		}
		module.exports = _typeof, module.exports.__esModule = true, module.exports["default"] = module.exports; 
	} (_typeof));
	return _typeof.exports;
}

var hasRequiredRegeneratorRuntime;

function requireRegeneratorRuntime () {
	if (hasRequiredRegeneratorRuntime) return regeneratorRuntime$1.exports;
	hasRequiredRegeneratorRuntime = 1;
	(function (module) {
		var _typeof = require_typeof()["default"];
		function _regeneratorRuntime() {
		  module.exports = _regeneratorRuntime = function _regeneratorRuntime() {
		    return e;
		  }, module.exports.__esModule = true, module.exports["default"] = module.exports;
		  var t,
		    e = {},
		    r = Object.prototype,
		    n = r.hasOwnProperty,
		    o = Object.defineProperty || function (t, e, r) {
		      t[e] = r.value;
		    },
		    i = "function" == typeof Symbol ? Symbol : {},
		    a = i.iterator || "@@iterator",
		    c = i.asyncIterator || "@@asyncIterator",
		    u = i.toStringTag || "@@toStringTag";
		  function define(t, e, r) {
		    return Object.defineProperty(t, e, {
		      value: r,
		      enumerable: !0,
		      configurable: !0,
		      writable: !0
		    }), t[e];
		  }
		  try {
		    define({}, "");
		  } catch (t) {
		    define = function define(t, e, r) {
		      return t[e] = r;
		    };
		  }
		  function wrap(t, e, r, n) {
		    var i = e && e.prototype instanceof Generator ? e : Generator,
		      a = Object.create(i.prototype),
		      c = new Context(n || []);
		    return o(a, "_invoke", {
		      value: makeInvokeMethod(t, r, c)
		    }), a;
		  }
		  function tryCatch(t, e, r) {
		    try {
		      return {
		        type: "normal",
		        arg: t.call(e, r)
		      };
		    } catch (t) {
		      return {
		        type: "throw",
		        arg: t
		      };
		    }
		  }
		  e.wrap = wrap;
		  var h = "suspendedStart",
		    l = "suspendedYield",
		    f = "executing",
		    s = "completed",
		    y = {};
		  function Generator() {}
		  function GeneratorFunction() {}
		  function GeneratorFunctionPrototype() {}
		  var p = {};
		  define(p, a, function () {
		    return this;
		  });
		  var d = Object.getPrototypeOf,
		    v = d && d(d(values([])));
		  v && v !== r && n.call(v, a) && (p = v);
		  var g = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(p);
		  function defineIteratorMethods(t) {
		    ["next", "throw", "return"].forEach(function (e) {
		      define(t, e, function (t) {
		        return this._invoke(e, t);
		      });
		    });
		  }
		  function AsyncIterator(t, e) {
		    function invoke(r, o, i, a) {
		      var c = tryCatch(t[r], t, o);
		      if ("throw" !== c.type) {
		        var u = c.arg,
		          h = u.value;
		        return h && "object" == _typeof(h) && n.call(h, "__await") ? e.resolve(h.__await).then(function (t) {
		          invoke("next", t, i, a);
		        }, function (t) {
		          invoke("throw", t, i, a);
		        }) : e.resolve(h).then(function (t) {
		          u.value = t, i(u);
		        }, function (t) {
		          return invoke("throw", t, i, a);
		        });
		      }
		      a(c.arg);
		    }
		    var r;
		    o(this, "_invoke", {
		      value: function value(t, n) {
		        function callInvokeWithMethodAndArg() {
		          return new e(function (e, r) {
		            invoke(t, n, e, r);
		          });
		        }
		        return r = r ? r.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
		      }
		    });
		  }
		  function makeInvokeMethod(e, r, n) {
		    var o = h;
		    return function (i, a) {
		      if (o === f) throw new Error("Generator is already running");
		      if (o === s) {
		        if ("throw" === i) throw a;
		        return {
		          value: t,
		          done: !0
		        };
		      }
		      for (n.method = i, n.arg = a;;) {
		        var c = n.delegate;
		        if (c) {
		          var u = maybeInvokeDelegate(c, n);
		          if (u) {
		            if (u === y) continue;
		            return u;
		          }
		        }
		        if ("next" === n.method) n.sent = n._sent = n.arg;else if ("throw" === n.method) {
		          if (o === h) throw o = s, n.arg;
		          n.dispatchException(n.arg);
		        } else "return" === n.method && n.abrupt("return", n.arg);
		        o = f;
		        var p = tryCatch(e, r, n);
		        if ("normal" === p.type) {
		          if (o = n.done ? s : l, p.arg === y) continue;
		          return {
		            value: p.arg,
		            done: n.done
		          };
		        }
		        "throw" === p.type && (o = s, n.method = "throw", n.arg = p.arg);
		      }
		    };
		  }
		  function maybeInvokeDelegate(e, r) {
		    var n = r.method,
		      o = e.iterator[n];
		    if (o === t) return r.delegate = null, "throw" === n && e.iterator["return"] && (r.method = "return", r.arg = t, maybeInvokeDelegate(e, r), "throw" === r.method) || "return" !== n && (r.method = "throw", r.arg = new TypeError("The iterator does not provide a '" + n + "' method")), y;
		    var i = tryCatch(o, e.iterator, r.arg);
		    if ("throw" === i.type) return r.method = "throw", r.arg = i.arg, r.delegate = null, y;
		    var a = i.arg;
		    return a ? a.done ? (r[e.resultName] = a.value, r.next = e.nextLoc, "return" !== r.method && (r.method = "next", r.arg = t), r.delegate = null, y) : a : (r.method = "throw", r.arg = new TypeError("iterator result is not an object"), r.delegate = null, y);
		  }
		  function pushTryEntry(t) {
		    var e = {
		      tryLoc: t[0]
		    };
		    1 in t && (e.catchLoc = t[1]), 2 in t && (e.finallyLoc = t[2], e.afterLoc = t[3]), this.tryEntries.push(e);
		  }
		  function resetTryEntry(t) {
		    var e = t.completion || {};
		    e.type = "normal", delete e.arg, t.completion = e;
		  }
		  function Context(t) {
		    this.tryEntries = [{
		      tryLoc: "root"
		    }], t.forEach(pushTryEntry, this), this.reset(!0);
		  }
		  function values(e) {
		    if (e || "" === e) {
		      var r = e[a];
		      if (r) return r.call(e);
		      if ("function" == typeof e.next) return e;
		      if (!isNaN(e.length)) {
		        var o = -1,
		          i = function next() {
		            for (; ++o < e.length;) if (n.call(e, o)) return next.value = e[o], next.done = !1, next;
		            return next.value = t, next.done = !0, next;
		          };
		        return i.next = i;
		      }
		    }
		    throw new TypeError(_typeof(e) + " is not iterable");
		  }
		  return GeneratorFunction.prototype = GeneratorFunctionPrototype, o(g, "constructor", {
		    value: GeneratorFunctionPrototype,
		    configurable: !0
		  }), o(GeneratorFunctionPrototype, "constructor", {
		    value: GeneratorFunction,
		    configurable: !0
		  }), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, u, "GeneratorFunction"), e.isGeneratorFunction = function (t) {
		    var e = "function" == typeof t && t.constructor;
		    return !!e && (e === GeneratorFunction || "GeneratorFunction" === (e.displayName || e.name));
		  }, e.mark = function (t) {
		    return Object.setPrototypeOf ? Object.setPrototypeOf(t, GeneratorFunctionPrototype) : (t.__proto__ = GeneratorFunctionPrototype, define(t, u, "GeneratorFunction")), t.prototype = Object.create(g), t;
		  }, e.awrap = function (t) {
		    return {
		      __await: t
		    };
		  }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, c, function () {
		    return this;
		  }), e.AsyncIterator = AsyncIterator, e.async = function (t, r, n, o, i) {
		    void 0 === i && (i = Promise);
		    var a = new AsyncIterator(wrap(t, r, n, o), i);
		    return e.isGeneratorFunction(r) ? a : a.next().then(function (t) {
		      return t.done ? t.value : a.next();
		    });
		  }, defineIteratorMethods(g), define(g, u, "Generator"), define(g, a, function () {
		    return this;
		  }), define(g, "toString", function () {
		    return "[object Generator]";
		  }), e.keys = function (t) {
		    var e = Object(t),
		      r = [];
		    for (var n in e) r.push(n);
		    return r.reverse(), function next() {
		      for (; r.length;) {
		        var t = r.pop();
		        if (t in e) return next.value = t, next.done = !1, next;
		      }
		      return next.done = !0, next;
		    };
		  }, e.values = values, Context.prototype = {
		    constructor: Context,
		    reset: function reset(e) {
		      if (this.prev = 0, this.next = 0, this.sent = this._sent = t, this.done = !1, this.delegate = null, this.method = "next", this.arg = t, this.tryEntries.forEach(resetTryEntry), !e) for (var r in this) "t" === r.charAt(0) && n.call(this, r) && !isNaN(+r.slice(1)) && (this[r] = t);
		    },
		    stop: function stop() {
		      this.done = !0;
		      var t = this.tryEntries[0].completion;
		      if ("throw" === t.type) throw t.arg;
		      return this.rval;
		    },
		    dispatchException: function dispatchException(e) {
		      if (this.done) throw e;
		      var r = this;
		      function handle(n, o) {
		        return a.type = "throw", a.arg = e, r.next = n, o && (r.method = "next", r.arg = t), !!o;
		      }
		      for (var o = this.tryEntries.length - 1; o >= 0; --o) {
		        var i = this.tryEntries[o],
		          a = i.completion;
		        if ("root" === i.tryLoc) return handle("end");
		        if (i.tryLoc <= this.prev) {
		          var c = n.call(i, "catchLoc"),
		            u = n.call(i, "finallyLoc");
		          if (c && u) {
		            if (this.prev < i.catchLoc) return handle(i.catchLoc, !0);
		            if (this.prev < i.finallyLoc) return handle(i.finallyLoc);
		          } else if (c) {
		            if (this.prev < i.catchLoc) return handle(i.catchLoc, !0);
		          } else {
		            if (!u) throw new Error("try statement without catch or finally");
		            if (this.prev < i.finallyLoc) return handle(i.finallyLoc);
		          }
		        }
		      }
		    },
		    abrupt: function abrupt(t, e) {
		      for (var r = this.tryEntries.length - 1; r >= 0; --r) {
		        var o = this.tryEntries[r];
		        if (o.tryLoc <= this.prev && n.call(o, "finallyLoc") && this.prev < o.finallyLoc) {
		          var i = o;
		          break;
		        }
		      }
		      i && ("break" === t || "continue" === t) && i.tryLoc <= e && e <= i.finallyLoc && (i = null);
		      var a = i ? i.completion : {};
		      return a.type = t, a.arg = e, i ? (this.method = "next", this.next = i.finallyLoc, y) : this.complete(a);
		    },
		    complete: function complete(t, e) {
		      if ("throw" === t.type) throw t.arg;
		      return "break" === t.type || "continue" === t.type ? this.next = t.arg : "return" === t.type ? (this.rval = this.arg = t.arg, this.method = "return", this.next = "end") : "normal" === t.type && e && (this.next = e), y;
		    },
		    finish: function finish(t) {
		      for (var e = this.tryEntries.length - 1; e >= 0; --e) {
		        var r = this.tryEntries[e];
		        if (r.finallyLoc === t) return this.complete(r.completion, r.afterLoc), resetTryEntry(r), y;
		      }
		    },
		    "catch": function _catch(t) {
		      for (var e = this.tryEntries.length - 1; e >= 0; --e) {
		        var r = this.tryEntries[e];
		        if (r.tryLoc === t) {
		          var n = r.completion;
		          if ("throw" === n.type) {
		            var o = n.arg;
		            resetTryEntry(r);
		          }
		          return o;
		        }
		      }
		      throw new Error("illegal catch attempt");
		    },
		    delegateYield: function delegateYield(e, r, n) {
		      return this.delegate = {
		        iterator: values(e),
		        resultName: r,
		        nextLoc: n
		      }, "next" === this.method && (this.arg = t), y;
		    }
		  }, e;
		}
		module.exports = _regeneratorRuntime, module.exports.__esModule = true, module.exports["default"] = module.exports; 
	} (regeneratorRuntime$1));
	return regeneratorRuntime$1.exports;
}

var regenerator;
var hasRequiredRegenerator;

function requireRegenerator () {
	if (hasRequiredRegenerator) return regenerator;
	hasRequiredRegenerator = 1;
	// TODO(Babel 8): Remove this file.

	var runtime = requireRegeneratorRuntime()();
	regenerator = runtime;

	// Copied from https://github.com/facebook/regenerator/blob/main/packages/runtime/runtime.js#L736=
	try {
	  regeneratorRuntime = runtime;
	} catch (accidentalStrictMode) {
	  if (typeof globalThis === "object") {
	    globalThis.regeneratorRuntime = runtime;
	  } else {
	    Function("r", "regeneratorRuntime = r")(runtime);
	  }
	}
	return regenerator;
}

var asyncToGenerator = {exports: {}};

var hasRequiredAsyncToGenerator;

function requireAsyncToGenerator () {
	if (hasRequiredAsyncToGenerator) return asyncToGenerator.exports;
	hasRequiredAsyncToGenerator = 1;
	(function (module) {
		function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
		  try {
		    var info = gen[key](arg);
		    var value = info.value;
		  } catch (error) {
		    reject(error);
		    return;
		  }
		  if (info.done) {
		    resolve(value);
		  } else {
		    Promise.resolve(value).then(_next, _throw);
		  }
		}
		function _asyncToGenerator(fn) {
		  return function () {
		    var self = this,
		      args = arguments;
		    return new Promise(function (resolve, reject) {
		      var gen = fn.apply(self, args);
		      function _next(value) {
		        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
		      }
		      function _throw(err) {
		        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
		      }
		      _next(undefined);
		    });
		  };
		}
		module.exports = _asyncToGenerator, module.exports.__esModule = true, module.exports["default"] = module.exports; 
	} (asyncToGenerator));
	return asyncToGenerator.exports;
}

var defineProperty = {exports: {}};

var toPropertyKey = {exports: {}};

var toPrimitive = {exports: {}};

var hasRequiredToPrimitive;

function requireToPrimitive () {
	if (hasRequiredToPrimitive) return toPrimitive.exports;
	hasRequiredToPrimitive = 1;
	(function (module) {
		var _typeof = require_typeof()["default"];
		function toPrimitive(t, r) {
		  if ("object" != _typeof(t) || !t) return t;
		  var e = t[Symbol.toPrimitive];
		  if (void 0 !== e) {
		    var i = e.call(t, r || "default");
		    if ("object" != _typeof(i)) return i;
		    throw new TypeError("@@toPrimitive must return a primitive value.");
		  }
		  return ("string" === r ? String : Number)(t);
		}
		module.exports = toPrimitive, module.exports.__esModule = true, module.exports["default"] = module.exports; 
	} (toPrimitive));
	return toPrimitive.exports;
}

var hasRequiredToPropertyKey;

function requireToPropertyKey () {
	if (hasRequiredToPropertyKey) return toPropertyKey.exports;
	hasRequiredToPropertyKey = 1;
	(function (module) {
		var _typeof = require_typeof()["default"];
		var toPrimitive = requireToPrimitive();
		function toPropertyKey(t) {
		  var i = toPrimitive(t, "string");
		  return "symbol" == _typeof(i) ? i : String(i);
		}
		module.exports = toPropertyKey, module.exports.__esModule = true, module.exports["default"] = module.exports; 
	} (toPropertyKey));
	return toPropertyKey.exports;
}

var hasRequiredDefineProperty;

function requireDefineProperty () {
	if (hasRequiredDefineProperty) return defineProperty.exports;
	hasRequiredDefineProperty = 1;
	(function (module) {
		var toPropertyKey = requireToPropertyKey();
		function _defineProperty(obj, key, value) {
		  key = toPropertyKey(key);
		  if (key in obj) {
		    Object.defineProperty(obj, key, {
		      value: value,
		      enumerable: true,
		      configurable: true,
		      writable: true
		    });
		  } else {
		    obj[key] = value;
		  }
		  return obj;
		}
		module.exports = _defineProperty, module.exports.__esModule = true, module.exports["default"] = module.exports; 
	} (defineProperty));
	return defineProperty.exports;
}

var isRetryAllowed;
var hasRequiredIsRetryAllowed;

function requireIsRetryAllowed () {
	if (hasRequiredIsRetryAllowed) return isRetryAllowed;
	hasRequiredIsRetryAllowed = 1;

	const denyList = new Set([
		'ENOTFOUND',
		'ENETUNREACH',

		// SSL errors from https://github.com/nodejs/node/blob/fc8e3e2cdc521978351de257030db0076d79e0ab/src/crypto/crypto_common.cc#L301-L328
		'UNABLE_TO_GET_ISSUER_CERT',
		'UNABLE_TO_GET_CRL',
		'UNABLE_TO_DECRYPT_CERT_SIGNATURE',
		'UNABLE_TO_DECRYPT_CRL_SIGNATURE',
		'UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY',
		'CERT_SIGNATURE_FAILURE',
		'CRL_SIGNATURE_FAILURE',
		'CERT_NOT_YET_VALID',
		'CERT_HAS_EXPIRED',
		'CRL_NOT_YET_VALID',
		'CRL_HAS_EXPIRED',
		'ERROR_IN_CERT_NOT_BEFORE_FIELD',
		'ERROR_IN_CERT_NOT_AFTER_FIELD',
		'ERROR_IN_CRL_LAST_UPDATE_FIELD',
		'ERROR_IN_CRL_NEXT_UPDATE_FIELD',
		'OUT_OF_MEM',
		'DEPTH_ZERO_SELF_SIGNED_CERT',
		'SELF_SIGNED_CERT_IN_CHAIN',
		'UNABLE_TO_GET_ISSUER_CERT_LOCALLY',
		'UNABLE_TO_VERIFY_LEAF_SIGNATURE',
		'CERT_CHAIN_TOO_LONG',
		'CERT_REVOKED',
		'INVALID_CA',
		'PATH_LENGTH_EXCEEDED',
		'INVALID_PURPOSE',
		'CERT_UNTRUSTED',
		'CERT_REJECTED',
		'HOSTNAME_MISMATCH'
	]);

	// TODO: Use `error?.code` when targeting Node.js 14
	isRetryAllowed = error => !denyList.has(error && error.code);
	return isRetryAllowed;
}

var hasRequiredCjs;

function requireCjs () {
	if (hasRequiredCjs) return cjs;
	hasRequiredCjs = 1;

	var _interopRequireDefault = requireInteropRequireDefault();

	Object.defineProperty(cjs, "__esModule", {
	  value: true
	});
	cjs.isNetworkError = isNetworkError;
	cjs.isRetryableError = isRetryableError;
	cjs.isSafeRequestError = isSafeRequestError;
	cjs.isIdempotentRequestError = isIdempotentRequestError;
	cjs.isNetworkOrIdempotentRequestError = isNetworkOrIdempotentRequestError;
	cjs.exponentialDelay = exponentialDelay;
	cjs.default = axiosRetry;
	cjs.DEFAULT_OPTIONS = cjs.namespace = void 0;

	var _regenerator = _interopRequireDefault(requireRegenerator());

	var _typeof2 = _interopRequireDefault(require_typeof());

	var _asyncToGenerator2 = _interopRequireDefault(requireAsyncToGenerator());

	var _defineProperty2 = _interopRequireDefault(requireDefineProperty());

	var _isRetryAllowed = _interopRequireDefault(requireIsRetryAllowed());

	function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }

	function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

	var namespace = 'axios-retry';
	/**
	 * @param  {Error}  error
	 * @return {boolean}
	 */

	cjs.namespace = namespace;

	function isNetworkError(error) {
	  var CODE_EXCLUDE_LIST = ['ERR_CANCELED', 'ECONNABORTED'];
	  return !error.response && Boolean(error.code) && // Prevents retrying cancelled requests
	  !CODE_EXCLUDE_LIST.includes(error.code) && // Prevents retrying timed out & cancelled requests
	  (0, _isRetryAllowed.default)(error) // Prevents retrying unsafe errors
	  ;
	}

	var SAFE_HTTP_METHODS = ['get', 'head', 'options'];
	var IDEMPOTENT_HTTP_METHODS = SAFE_HTTP_METHODS.concat(['put', 'delete']);
	/**
	 * @param  {Error}  error
	 * @return {boolean}
	 */

	function isRetryableError(error) {
	  return error.code !== 'ECONNABORTED' && (!error.response || error.response.status >= 500 && error.response.status <= 599);
	}
	/**
	 * @param  {Error}  error
	 * @return {boolean}
	 */


	function isSafeRequestError(error) {
	  if (!error.config) {
	    // Cannot determine if the request can be retried
	    return false;
	  }

	  return isRetryableError(error) && SAFE_HTTP_METHODS.indexOf(error.config.method) !== -1;
	}
	/**
	 * @param  {Error}  error
	 * @return {boolean}
	 */


	function isIdempotentRequestError(error) {
	  if (!error.config) {
	    // Cannot determine if the request can be retried
	    return false;
	  }

	  return isRetryableError(error) && IDEMPOTENT_HTTP_METHODS.indexOf(error.config.method) !== -1;
	}
	/**
	 * @param  {Error}  error
	 * @return {boolean}
	 */


	function isNetworkOrIdempotentRequestError(error) {
	  return isNetworkError(error) || isIdempotentRequestError(error);
	}
	/**
	 * @return {number} - delay in milliseconds, always 0
	 */


	function noDelay() {
	  return 0;
	}
	/**
	 * Set delayFactor 1000 for an exponential delay to occur on the order
	 * of seconds
	 * @param  {number} [retryNumber=0]
	 * @param  {Error}  error - unused; for existing API of retryDelay callback
	 * @param  {number} [delayFactor=100] milliseconds
	 * @return {number} - delay in milliseconds
	 */


	function exponentialDelay() {
	  var retryNumber = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
	  var delayFactor = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 100;
	  var delay = Math.pow(2, retryNumber) * delayFactor;
	  var randomSum = delay * 0.2 * Math.random(); // 0-20% of the delay

	  return delay + randomSum;
	}
	/** @type {IAxiosRetryConfig} */


	var DEFAULT_OPTIONS = {
	  retries: 3,
	  retryCondition: isNetworkOrIdempotentRequestError,
	  retryDelay: noDelay,
	  shouldResetTimeout: false,
	  onRetry: function onRetry() {}
	};
	/**
	 * Returns the axios-retry options for the current request
	 * @param  {AxiosRequestConfig} config
	 * @param  {IAxiosRetryConfig} defaultOptions
	 * @return {IAxiosRetryConfigExtended}
	 */

	cjs.DEFAULT_OPTIONS = DEFAULT_OPTIONS;

	function getRequestOptions(config, defaultOptions) {
	  return _objectSpread(_objectSpread(_objectSpread({}, DEFAULT_OPTIONS), defaultOptions), config[namespace]);
	}
	/**
	 * Initializes and returns the retry state for the given request/config
	 * @param  {AxiosRequestConfig} config
	 * @param  {IAxiosRetryConfig} defaultOptions
	 * @return {IAxiosRetryConfigExtended}
	 */


	function getCurrentState(config, defaultOptions) {
	  var currentState = getRequestOptions(config, defaultOptions);
	  currentState.retryCount = currentState.retryCount || 0;
	  config[namespace] = currentState;
	  return currentState;
	}
	/**
	 * @param  {Axios} axios
	 * @param  {AxiosRequestConfig} config
	 */


	function fixConfig(axios, config) {
	  if (axios.defaults.agent === config.agent) {
	    delete config.agent;
	  }

	  if (axios.defaults.httpAgent === config.httpAgent) {
	    delete config.httpAgent;
	  }

	  if (axios.defaults.httpsAgent === config.httpsAgent) {
	    delete config.httpsAgent;
	  }
	}
	/**
	 * Checks retryCondition if request can be retried. Handles it's returning value or Promise.
	 * @param  {IAxiosRetryConfigExtended} currentState
	 * @param  {Error} error
	 * @return {Promise<boolean>}
	 */


	function shouldRetry(_x, _x2) {
	  return _shouldRetry.apply(this, arguments);
	}
	/**
	 * Adds response interceptors to an axios instance to retry requests failed due to network issues
	 *
	 * @example
	 *
	 * import axios from 'axios';
	 *
	 * axiosRetry(axios, { retries: 3 });
	 *
	 * axios.get('http://example.com/test') // The first request fails and the second returns 'ok'
	 *   .then(result => {
	 *     result.data; // 'ok'
	 *   });
	 *
	 * // Exponential back-off retry delay between requests
	 * axiosRetry(axios, { retryDelay : axiosRetry.exponentialDelay});
	 *
	 * // Custom retry delay
	 * axiosRetry(axios, { retryDelay : (retryCount) => {
	 *   return retryCount * 1000;
	 * }});
	 *
	 * // Also works with custom axios instances
	 * const client = axios.create({ baseURL: 'http://example.com' });
	 * axiosRetry(client, { retries: 3 });
	 *
	 * client.get('/test') // The first request fails and the second returns 'ok'
	 *   .then(result => {
	 *     result.data; // 'ok'
	 *   });
	 *
	 * // Allows request-specific configuration
	 * client
	 *   .get('/test', {
	 *     'axios-retry': {
	 *       retries: 0
	 *     }
	 *   })
	 *   .catch(error => { // The first request fails
	 *     error !== undefined
	 *   });
	 *
	 * @param {Axios} axios An axios instance (the axios object or one created from axios.create)
	 * @param {Object} [defaultOptions]
	 * @param {number} [defaultOptions.retries=3] Number of retries
	 * @param {boolean} [defaultOptions.shouldResetTimeout=false]
	 *        Defines if the timeout should be reset between retries
	 * @param {Function} [defaultOptions.retryCondition=isNetworkOrIdempotentRequestError]
	 *        A function to determine if the error can be retried
	 * @param {Function} [defaultOptions.retryDelay=noDelay]
	 *        A function to determine the delay between retry requests
	 * @param {Function} [defaultOptions.onRetry=()=>{}]
	 *        A function to get notified when a retry occurs
	 * @return {{ requestInterceptorId: number, responseInterceptorId: number }}
	 *        The ids of the interceptors added to the request and to the response (so they can be ejected at a later time)
	 */


	function _shouldRetry() {
	  _shouldRetry = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(currentState, error) {
	    var retries, retryCondition, shouldRetryOrPromise, shouldRetryPromiseResult;
	    return _regenerator.default.wrap(function _callee2$(_context2) {
	      while (1) {
	        switch (_context2.prev = _context2.next) {
	          case 0:
	            retries = currentState.retries, retryCondition = currentState.retryCondition;
	            shouldRetryOrPromise = currentState.retryCount < retries && retryCondition(error); // This could be a promise

	            if (!((0, _typeof2.default)(shouldRetryOrPromise) === 'object')) {
	              _context2.next = 13;
	              break;
	            }

	            _context2.prev = 3;
	            _context2.next = 6;
	            return shouldRetryOrPromise;

	          case 6:
	            shouldRetryPromiseResult = _context2.sent;
	            return _context2.abrupt("return", shouldRetryPromiseResult !== false);

	          case 10:
	            _context2.prev = 10;
	            _context2.t0 = _context2["catch"](3);
	            return _context2.abrupt("return", false);

	          case 13:
	            return _context2.abrupt("return", shouldRetryOrPromise);

	          case 14:
	          case "end":
	            return _context2.stop();
	        }
	      }
	    }, _callee2, null, [[3, 10]]);
	  }));
	  return _shouldRetry.apply(this, arguments);
	}

	function axiosRetry(axios, defaultOptions) {
	  var requestInterceptorId = axios.interceptors.request.use(function (config) {
	    var currentState = getCurrentState(config, defaultOptions);
	    currentState.lastRequestTime = Date.now();
	    return config;
	  });
	  var responseInterceptorId = axios.interceptors.response.use(null, /*#__PURE__*/function () {
	    var _ref = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(error) {
	      var config, currentState, retryDelay, shouldResetTimeout, onRetry, delay, lastRequestDuration, timeout;
	      return _regenerator.default.wrap(function _callee$(_context) {
	        while (1) {
	          switch (_context.prev = _context.next) {
	            case 0:
	              config = error.config; // If we have no information to retry the request

	              if (config) {
	                _context.next = 3;
	                break;
	              }

	              return _context.abrupt("return", Promise.reject(error));

	            case 3:
	              currentState = getCurrentState(config, defaultOptions);
	              _context.next = 6;
	              return shouldRetry(currentState, error);

	            case 6:
	              if (!_context.sent) {
	                _context.next = 21;
	                break;
	              }

	              currentState.retryCount += 1;
	              retryDelay = currentState.retryDelay, shouldResetTimeout = currentState.shouldResetTimeout, onRetry = currentState.onRetry;
	              delay = retryDelay(currentState.retryCount, error); // Axios fails merging this configuration to the default configuration because it has an issue
	              // with circular structures: https://github.com/mzabriskie/axios/issues/370

	              fixConfig(axios, config);

	              if (!(!shouldResetTimeout && config.timeout && currentState.lastRequestTime)) {
	                _context.next = 17;
	                break;
	              }

	              lastRequestDuration = Date.now() - currentState.lastRequestTime;
	              timeout = config.timeout - lastRequestDuration - delay;

	              if (!(timeout <= 0)) {
	                _context.next = 16;
	                break;
	              }

	              return _context.abrupt("return", Promise.reject(error));

	            case 16:
	              config.timeout = timeout;

	            case 17:
	              config.transformRequest = [function (data) {
	                return data;
	              }];
	              _context.next = 20;
	              return onRetry(currentState.retryCount, error, config);

	            case 20:
	              return _context.abrupt("return", new Promise(function (resolve) {
	                return setTimeout(function () {
	                  return resolve(axios(config));
	                }, delay);
	              }));

	            case 21:
	              return _context.abrupt("return", Promise.reject(error));

	            case 22:
	            case "end":
	              return _context.stop();
	          }
	        }
	      }, _callee);
	    }));

	    return function (_x3) {
	      return _ref.apply(this, arguments);
	    };
	  }());
	  return {
	    requestInterceptorId: requestInterceptorId,
	    responseInterceptorId: responseInterceptorId
	  };
	} // Compatibility with CommonJS


	axiosRetry.isNetworkError = isNetworkError;
	axiosRetry.isSafeRequestError = isSafeRequestError;
	axiosRetry.isIdempotentRequestError = isIdempotentRequestError;
	axiosRetry.isNetworkOrIdempotentRequestError = isNetworkOrIdempotentRequestError;
	axiosRetry.exponentialDelay = exponentialDelay;
	axiosRetry.isRetryableError = isRetryableError;
	
	return cjs;
}

var hasRequiredAxiosRetry;

function requireAxiosRetry () {
	if (hasRequiredAxiosRetry) return axiosRetry.exports;
	hasRequiredAxiosRetry = 1;
	const axiosRetry$1 = requireCjs().default;

	axiosRetry.exports = axiosRetry$1;
	axiosRetry.exports.default = axiosRetry$1;
	return axiosRetry.exports;
}

var hasRequiredCommon$2;

function requireCommon$2 () {
	if (hasRequiredCommon$2) return common$2;
	hasRequiredCommon$2 = 1;
	/* tslint:disable */
	/* eslint-disable */
	/**
	 * IdentityNow Beta API
	 * Use these APIs to interact with the IdentityNow platform to achieve repeatable, automated processes with greater scalability. These APIs are in beta and are subject to change. We encourage you to join the SailPoint Developer Community forum at https://developer.sailpoint.com/discuss to connect with other developers using our APIs.
	 *
	 * The version of the OpenAPI document: 3.1.0-beta
	 *
	 *
	 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
	 * https://openapi-generator.tech
	 * Do not edit the class manually.
	 */
	var __assign = (commonjsGlobal && commonjsGlobal.__assign) || function () {
	    __assign = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign.apply(this, arguments);
	};
	var __awaiter = (commonjsGlobal && commonjsGlobal.__awaiter) || function (thisArg, _arguments, P, generator) {
	    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
	    return new (P || (P = Promise))(function (resolve, reject) {
	        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
	        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
	        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
	        step((generator = generator.apply(thisArg, _arguments || [])).next());
	    });
	};
	var __generator = (commonjsGlobal && commonjsGlobal.__generator) || function (thisArg, body) {
	    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
	    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
	    function verb(n) { return function (v) { return step([n, v]); }; }
	    function step(op) {
	        if (f) throw new TypeError("Generator is already executing.");
	        while (g && (g = 0, op[0] && (_ = 0)), _) try {
	            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
	            if (y = 0, t) op = [op[0] & 2, t.value];
	            switch (op[0]) {
	                case 0: case 1: t = op; break;
	                case 4: _.label++; return { value: op[1], done: false };
	                case 5: _.label++; y = op[1]; op = [0]; continue;
	                case 7: op = _.ops.pop(); _.trys.pop(); continue;
	                default:
	                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
	                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
	                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
	                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
	                    if (t[2]) _.ops.pop();
	                    _.trys.pop(); continue;
	            }
	            op = body.call(thisArg, _);
	        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
	        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
	    }
	};
	var __importDefault = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
	    return (mod && mod.__esModule) ? mod : { "default": mod };
	};
	Object.defineProperty(common$2, "__esModule", { value: true });
	common$2.createRequestFunction = common$2.toPathString = common$2.serializeDataIfNeeded = common$2.setSearchParams = common$2.setOAuthToObject = common$2.setBearerAuthToObject = common$2.setBasicAuthToObject = common$2.setApiKeyToObject = common$2.assertParamExists = common$2.DUMMY_BASE_URL = void 0;
	var base_1 = requireBase$1();
	var axios_retry_1 = __importDefault(requireAxiosRetry());
	/**
	 *
	 * @export
	 */
	common$2.DUMMY_BASE_URL = 'https://example.com';
	/**
	 *
	 * @throws {RequiredError}
	 * @export
	 */
	var assertParamExists = function (functionName, paramName, paramValue) {
	    if (paramValue === null || paramValue === undefined) {
	        throw new base_1.RequiredError(paramName, "Required parameter ".concat(paramName, " was null or undefined when calling ").concat(functionName, "."));
	    }
	};
	common$2.assertParamExists = assertParamExists;
	/**
	 *
	 * @export
	 */
	var setApiKeyToObject = function (object, keyParamName, configuration) {
	    return __awaiter(this, void 0, void 0, function () {
	        var localVarApiKeyValue, _a;
	        return __generator(this, function (_b) {
	            switch (_b.label) {
	                case 0:
	                    if (!(configuration && configuration.apiKey)) return [3 /*break*/, 5];
	                    if (!(typeof configuration.apiKey === 'function')) return [3 /*break*/, 2];
	                    return [4 /*yield*/, configuration.apiKey(keyParamName)];
	                case 1:
	                    _a = _b.sent();
	                    return [3 /*break*/, 4];
	                case 2: return [4 /*yield*/, configuration.apiKey];
	                case 3:
	                    _a = _b.sent();
	                    _b.label = 4;
	                case 4:
	                    localVarApiKeyValue = _a;
	                    object[keyParamName] = localVarApiKeyValue;
	                    _b.label = 5;
	                case 5: return [2 /*return*/];
	            }
	        });
	    });
	};
	common$2.setApiKeyToObject = setApiKeyToObject;
	/**
	 *
	 * @export
	 */
	var setBasicAuthToObject = function (object, configuration) {
	    if (configuration && (configuration.username || configuration.password)) {
	        object["auth"] = { username: configuration.username, password: configuration.password };
	    }
	};
	common$2.setBasicAuthToObject = setBasicAuthToObject;
	/**
	 *
	 * @export
	 */
	var setBearerAuthToObject = function (object, configuration) {
	    return __awaiter(this, void 0, void 0, function () {
	        var accessToken, _a;
	        return __generator(this, function (_b) {
	            switch (_b.label) {
	                case 0:
	                    if (!(configuration && configuration.accessToken)) return [3 /*break*/, 5];
	                    if (!(typeof configuration.accessToken === 'function')) return [3 /*break*/, 2];
	                    return [4 /*yield*/, configuration.accessToken()];
	                case 1:
	                    _a = _b.sent();
	                    return [3 /*break*/, 4];
	                case 2: return [4 /*yield*/, configuration.accessToken];
	                case 3:
	                    _a = _b.sent();
	                    _b.label = 4;
	                case 4:
	                    accessToken = _a;
	                    object["Authorization"] = "Bearer " + accessToken;
	                    _b.label = 5;
	                case 5: return [2 /*return*/];
	            }
	        });
	    });
	};
	common$2.setBearerAuthToObject = setBearerAuthToObject;
	/**
	 *
	 * @export
	 */
	var setOAuthToObject = function (object, name, scopes, configuration) {
	    return __awaiter(this, void 0, void 0, function () {
	        var localVarAccessTokenValue, _a;
	        return __generator(this, function (_b) {
	            switch (_b.label) {
	                case 0:
	                    if (!(configuration && configuration.accessToken)) return [3 /*break*/, 5];
	                    if (!(typeof configuration.accessToken === 'function')) return [3 /*break*/, 2];
	                    return [4 /*yield*/, configuration.accessToken(name, scopes)];
	                case 1:
	                    _a = _b.sent();
	                    return [3 /*break*/, 4];
	                case 2: return [4 /*yield*/, configuration.accessToken];
	                case 3:
	                    _a = _b.sent();
	                    _b.label = 4;
	                case 4:
	                    localVarAccessTokenValue = _a;
	                    object["Authorization"] = "Bearer " + localVarAccessTokenValue;
	                    _b.label = 5;
	                case 5: return [2 /*return*/];
	            }
	        });
	    });
	};
	common$2.setOAuthToObject = setOAuthToObject;
	/**
	 *
	 * @export
	 */
	var setSearchParams = function (url) {
	    var objects = [];
	    for (var _i = 1; _i < arguments.length; _i++) {
	        objects[_i - 1] = arguments[_i];
	    }
	    var searchParams = new URLSearchParams(url.search);
	    for (var _a = 0, objects_1 = objects; _a < objects_1.length; _a++) {
	        var object = objects_1[_a];
	        for (var key in object) {
	            if (Array.isArray(object[key])) {
	                searchParams.delete(key);
	                for (var _b = 0, _c = object[key]; _b < _c.length; _b++) {
	                    var item = _c[_b];
	                    searchParams.append(key, item);
	                }
	            }
	            else {
	                searchParams.set(key, object[key]);
	            }
	        }
	    }
	    url.search = searchParams.toString();
	};
	common$2.setSearchParams = setSearchParams;
	/**
	 *
	 * @export
	 */
	var serializeDataIfNeeded = function (value, requestOptions, configuration) {
	    var nonString = typeof value !== 'string';
	    var needsSerialization = nonString && configuration && configuration.isJsonMime
	        ? configuration.isJsonMime(requestOptions.headers['Content-Type'])
	        : nonString;
	    return needsSerialization
	        ? JSON.stringify(value !== undefined ? value : {})
	        : (value || "");
	};
	common$2.serializeDataIfNeeded = serializeDataIfNeeded;
	/**
	 *
	 * @export
	 */
	var toPathString = function (url) {
	    return url.pathname + url.search + url.hash;
	};
	common$2.toPathString = toPathString;
	/**
	 *
	 * @export
	 */
	var createRequestFunction = function (axiosArgs, globalAxios, BASE_PATH, configuration) {
	    return function (axios, basePath) {
	        if (axios === void 0) { axios = globalAxios; }
	        if (basePath === void 0) { basePath = BASE_PATH; }
	        (0, axios_retry_1.default)(globalAxios, configuration.retriesConfig);
	        axiosArgs.axiosOptions.headers['X-SailPoint-SDK'] = 'typescript-1.3.1';
	        axiosArgs.axiosOptions.headers['User-Agent'] = 'OpenAPI-Generator/1.3.1/ts';
	        var axiosRequestArgs = __assign(__assign({}, axiosArgs.axiosOptions), { url: ((configuration === null || configuration === void 0 ? void 0 : configuration.basePath) + "/beta" || basePath) + axiosArgs.url });
	        return axios.request(axiosRequestArgs);
	    };
	};
	common$2.createRequestFunction = createRequestFunction;
	
	return common$2;
}

var hasRequiredApi$1;

function requireApi$1 () {
	if (hasRequiredApi$1) return api$1;
	hasRequiredApi$1 = 1;
	(function (exports) {
		/* tslint:disable */
		/* eslint-disable */
		/**
		 * IdentityNow Beta API
		 * Use these APIs to interact with the IdentityNow platform to achieve repeatable, automated processes with greater scalability. These APIs are in beta and are subject to change. We encourage you to join the SailPoint Developer Community forum at https://developer.sailpoint.com/discuss to connect with other developers using our APIs.
		 *
		 * The version of the OpenAPI document: 3.1.0-beta
		 *
		 *
		 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
		 * https://openapi-generator.tech
		 * Do not edit the class manually.
		 */
		var __extends = (commonjsGlobal && commonjsGlobal.__extends) || (function () {
		    var extendStatics = function (d, b) {
		        extendStatics = Object.setPrototypeOf ||
		            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
		            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
		        return extendStatics(d, b);
		    };
		    return function (d, b) {
		        if (typeof b !== "function" && b !== null)
		            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
		        extendStatics(d, b);
		        function __() { this.constructor = d; }
		        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
		    };
		})();
		var __assign = (commonjsGlobal && commonjsGlobal.__assign) || function () {
		    __assign = Object.assign || function(t) {
		        for (var s, i = 1, n = arguments.length; i < n; i++) {
		            s = arguments[i];
		            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
		                t[p] = s[p];
		        }
		        return t;
		    };
		    return __assign.apply(this, arguments);
		};
		var __awaiter = (commonjsGlobal && commonjsGlobal.__awaiter) || function (thisArg, _arguments, P, generator) {
		    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
		    return new (P || (P = Promise))(function (resolve, reject) {
		        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
		        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
		        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
		        step((generator = generator.apply(thisArg, _arguments || [])).next());
		    });
		};
		var __generator = (commonjsGlobal && commonjsGlobal.__generator) || function (thisArg, body) {
		    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
		    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
		    function verb(n) { return function (v) { return step([n, v]); }; }
		    function step(op) {
		        if (f) throw new TypeError("Generator is already executing.");
		        while (g && (g = 0, op[0] && (_ = 0)), _) try {
		            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
		            if (y = 0, t) op = [op[0] & 2, t.value];
		            switch (op[0]) {
		                case 0: case 1: t = op; break;
		                case 4: _.label++; return { value: op[1], done: false };
		                case 5: _.label++; y = op[1]; op = [0]; continue;
		                case 7: op = _.ops.pop(); _.trys.pop(); continue;
		                default:
		                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
		                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
		                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
		                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
		                    if (t[2]) _.ops.pop();
		                    _.trys.pop(); continue;
		            }
		            op = body.call(thisArg, _);
		        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
		        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
		    }
		};
		var __importDefault = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
		    return (mod && mod.__esModule) ? mod : { "default": mod };
		};
		Object.defineProperty(exports, "__esModule", { value: true });
		exports.AccountUncorrelatedIdentityBetaTypeEnum = exports.AccountUncorrelatedAccountBetaTypeEnum = exports.AccountStatusChangedStatusChangeBetaNewStatusEnum = exports.AccountStatusChangedStatusChangeBetaPreviousStatusEnum = exports.AccountCorrelatedSourceBetaTypeEnum = exports.AccountCorrelatedIdentityBetaTypeEnum = exports.AccountCorrelatedAccountBetaTypeEnum = exports.AccountAttributesChangedSourceBetaTypeEnum = exports.AccountAttributesChangedIdentityBetaTypeEnum = exports.AccountAttributesChangedAccountBetaTypeEnum = exports.AccountAggregationStatusBetaStatusEnum = exports.AccountAggregationCompletedSourceBetaTypeEnum = exports.AccountAggregationCompletedBetaStatusEnum = exports.AccountAggregationBetaStatusEnum = exports.AccountActivityItemOperationBeta = exports.AccountActionBetaActionEnum = exports.AccessTypeBeta = exports.AccessRequestTypeBeta = exports.AccessRequestRecommendationItemTypeBeta = exports.AccessRequestPreApprovalRequestedItemsInnerBetaOperationEnum = exports.AccessRequestPreApprovalRequestedItemsInnerBetaTypeEnum = exports.AccessRequestPostApprovalRequestedItemsStatusInnerBetaOperationEnum = exports.AccessRequestPostApprovalRequestedItemsStatusInnerBetaTypeEnum = exports.AccessRequestPostApprovalRequestedItemsStatusInnerApprovalInfoInnerBetaApprovalDecisionEnum = exports.AccessRequestPostApprovalRequestedItemsStatusInnerApprovalInfoInnerApproverBetaTypeEnum = exports.AccessRequestPostApprovalRequestedByBetaTypeEnum = exports.AccessRequestPhasesBetaResultEnum = exports.AccessRequestPhasesBetaStateEnum = exports.AccessRequestItemResponseBetaDecisionEnum = exports.AccessRequestItemBetaTypeEnum = exports.AccessRequestDynamicApproverRequestedItemsInnerBetaOperationEnum = exports.AccessRequestDynamicApproverRequestedItemsInnerBetaTypeEnum = exports.AccessRequestDynamicApproverRequestedByBetaTypeEnum = exports.AccessRequestDynamicApprover1BetaTypeEnum = exports.AccessProfileUsageUsedByInnerBetaTypeEnum = exports.AccessProfileSourceRefBetaTypeEnum = exports.AccessProfileRefBetaTypeEnum = exports.AccessProfileApprovalSchemeBetaApproverTypeEnum = exports.AccessItemReviewedByBetaTypeEnum = exports.AccessItemRequesterDtoBetaTypeEnum = exports.AccessItemRequesterBetaTypeEnum = exports.AccessItemRequestedForDtoBetaTypeEnum = exports.AccessItemRequestedForBetaTypeEnum = exports.AccessItemRefBetaTypeEnum = exports.AccessItemOwnerDtoBetaTypeEnum = exports.AccessItemDiffBetaEventTypeEnum = exports.AccessItemApproverDtoBetaTypeEnum = exports.AccessCriteriaCriteriaListInnerBetaTypeEnum = exports.AccessConstraintBetaOperatorEnum = exports.AccessConstraintBetaTypeEnum = void 0;
		exports.CompletionStatusBeta = exports.CompletedApprovalStateBeta = exports.CompletedApprovalReviewedByBetaTypeEnum = exports.CompleteCampaignOptionsBetaAutoCompleteActionEnum = exports.CommonAccessTypeBeta = exports.CommonAccessItemStateBeta = exports.CommentDtoAuthorBetaTypeEnum = exports.CommentDto1AuthorBetaTypeEnum = exports.CloseAccessRequestBetaCompletionStatusEnum = exports.CloseAccessRequestBetaExecutionStatusEnum = exports.ClientTypeBeta = exports.CertificationTaskBetaStatusEnum = exports.CertificationTaskBetaTargetTypeEnum = exports.CertificationTaskBetaTypeEnum = exports.CertificationReferenceDtoBetaTypeEnum = exports.CertificationReferenceBetaTypeEnum = exports.CertificationPhaseBeta = exports.CampaignTemplateOwnerRefBetaTypeEnum = exports.CampaignReportBetaStatusEnum = exports.CampaignReportBetaTypeEnum = exports.CampaignReferenceBetaMandatoryCommentRequirementEnum = exports.CampaignReferenceBetaCorrelatedStatusEnum = exports.CampaignReferenceBetaCampaignTypeEnum = exports.CampaignReferenceBetaTypeEnum = exports.CampaignGeneratedCampaignBetaStatusEnum = exports.CampaignGeneratedCampaignBetaTypeEnum = exports.CampaignEndedCampaignBetaStatusEnum = exports.CampaignEndedCampaignBetaTypeEnum = exports.CampaignBetaMandatoryCommentRequirementEnum = exports.CampaignBetaCorrelatedStatusEnum = exports.CampaignBetaStatusEnum = exports.CampaignBetaTypeEnum = exports.CampaignAlertBetaLevelEnum = exports.CampaignActivatedCampaignBetaStatusEnum = exports.CampaignActivatedCampaignBetaTypeEnum = exports.BulkWorkgroupMembersRequestInnerBetaTypeEnum = exports.BulkTaggedObjectBetaOperationEnum = exports.BeforeProvisioningRuleDtoBetaTypeEnum = exports.AttributeDefinitionTypeBeta = exports.AttributeDefinitionSchemaBetaTypeEnum = exports.AttrSyncSourceBetaTypeEnum = exports.ApprovalStatusDtoOriginalOwnerBetaTypeEnum = exports.ApprovalStatusDtoCurrentOwnerBetaTypeEnum = exports.ApprovalStatusBeta = exports.ApprovalSchemeForRoleBetaApproverTypeEnum = exports.ApprovalSchemeBeta = exports.AdminReviewReassignReassignToBetaTypeEnum = exports.AccountsCollectedForAggregationSourceBetaTypeEnum = exports.AccountsCollectedForAggregationBetaStatusEnum = exports.AccountUncorrelatedSourceBetaTypeEnum = void 0;
		exports.FullcampaignBetaMandatoryCommentRequirementEnum = exports.FullcampaignBetaCorrelatedStatusEnum = exports.FullcampaignBetaStatusEnum = exports.FullcampaignBetaTypeEnum = exports.FullcampaignAllOfSourcesWithOrphanEntitlementsBetaTypeEnum = exports.FullcampaignAllOfSearchCampaignInfoReviewerBetaTypeEnum = exports.FullcampaignAllOfSearchCampaignInfoBetaTypeEnum = exports.FullcampaignAllOfRoleCompositionCampaignInfoRemediatorRefBetaTypeEnum = exports.FullcampaignAllOfFilterBetaTypeEnum = exports.FullcampaignAllOfBetaMandatoryCommentRequirementEnum = exports.FullcampaignAllOfBetaCorrelatedStatusEnum = exports.FormUsedByBetaTypeEnum = exports.FormOwnerBetaTypeEnum = exports.FormInstanceResponseBetaStateEnum = exports.FormInstanceRecipientBetaTypeEnum = exports.FormInstanceCreatedByBetaTypeEnum = exports.FormElementDynamicDataSourceConfigBetaObjectTypeEnum = exports.FormElementDynamicDataSourceConfigBetaIndicesEnum = exports.FormElementDynamicDataSourceBetaDataSourceTypeEnum = exports.FormElementBetaElementTypeEnum = exports.FormDefinitionInputBetaTypeEnum = exports.FormConditionBetaRuleOperatorEnum = exports.ExpressionBetaOperatorEnum = exports.ExportPayloadBetaIncludeTypesEnum = exports.ExportPayloadBetaExcludeTypesEnum = exports.ExportOptionsBetaIncludeTypesEnum = exports.ExportOptionsBetaExcludeTypesEnum = exports.ExecutionStatusBeta = exports.ExceptionCriteriaCriteriaListInnerBetaTypeEnum = exports.EntitlementRefBetaTypeEnum = exports.EntitlementOwnerBetaTypeEnum = exports.EntitlementApprovalSchemeBetaApproverTypeEnum = exports.EmailStatusDtoBetaVerificationStatusEnum = exports.DtoTypeBeta = exports.Delete202ResponseBetaTypeEnum = exports.DateCompareBetaOperatorEnum = exports.CustomPasswordInstructionBetaPageIdEnum = exports.CreateFormInstanceRequestBetaStateEnum = exports.CorrelatedGovernanceEventBetaTypeEnum = exports.ConnectorRuleValidationResponseBetaStateEnum = exports.ConnectorRuleUpdateRequestBetaTypeEnum = exports.ConnectorRuleResponseBetaTypeEnum = exports.ConnectorRuleCreateRequestBetaTypeEnum = exports.ConnectedObjectTypeBeta = exports.ConfigTypeEnumCamelBeta = exports.ConfigTypeEnumBeta = exports.ConditionRuleBetaValueTypeEnum = exports.ConditionRuleBetaOperatorEnum = exports.ConditionRuleBetaSourceTypeEnum = exports.ConditionEffectBetaEffectTypeEnum = void 0;
		exports.OwnerDtoBetaTypeEnum = exports.OutliersContributingFeatureAccessItemsBetaAccessTypeEnum = exports.OutlierSummaryBetaTypeEnum = exports.OutlierFeatureSummaryOutlierFeatureDisplayValuesInnerBetaValueTypeEnum = exports.OutlierContributingFeatureBetaValueTypeEnum = exports.OutlierBetaUnignoreTypeEnum = exports.OutlierBetaTypeEnum = exports.NonEmployeeSchemaAttributeTypeBeta = exports.NonEmployeeBulkUploadStatusBetaStatusEnum = exports.NonEmployeeBulkUploadJobBetaStatusEnum = exports.NativeChangeDetectionConfigBetaOperationsEnum = exports.NamedConstructsBeta = exports.MfaConfigTestResponseBetaStateEnum = exports.MediumBeta = exports.ManualWorkItemStateBeta = exports.ManualWorkItemDetailsOriginalOwnerBetaTypeEnum = exports.ManualWorkItemDetailsCurrentOwnerBetaTypeEnum = exports.ManagedClusterTypesBeta = exports.ManagedClientTypeBeta = exports.ManagedClientStatusEnumBeta = exports.MailFromAttributesBetaMailFromDomainStatusEnum = exports.LocaleOriginBeta = exports.ListWorkgroupMembers200ResponseInnerBetaTypeEnum = exports.LatestOutlierSummaryBetaTypeEnum = exports.KbaAuthResponseBetaStatusEnum = exports.JsonPatchOperationBetaOpEnum = exports.InvocationStatusTypeBeta = exports.ImportOptionsBetaDefaultReferencesEnum = exports.ImportOptionsBetaIncludeTypesEnum = exports.ImportOptionsBetaExcludeTypesEnum = exports.ImportObjectBetaTypeEnum = exports.IdentityWithNewAccessAccessRefsInnerBetaTypeEnum = exports.IdentitySyncJobBetaStatusEnum = exports.IdentityProfileAllOfOwnerBetaTypeEnum = exports.IdentityProfileAllOfAuthoritativeSourceBetaTypeEnum = exports.IdentityProfile1AllOfAuthoritativeSourceBetaTypeEnum = exports.IdentityPreviewResponseIdentityBetaTypeEnum = exports.IdentityDtoManagerRefBetaTypeEnum = exports.IdentityDtoBetaIdentityStatusEnum = exports.IdentityDtoBetaProcessingStateEnum = exports.IdentityDeletedIdentityBetaTypeEnum = exports.IdentityCreatedIdentityBetaTypeEnum = exports.IdentityCertificationTaskBetaStatusEnum = exports.IdentityCertificationTaskBetaTypeEnum = exports.IdentityBetaIdentityStatusEnum = exports.IdentityBetaProcessingStateEnum = exports.IdentityAttributesChangedIdentityBetaTypeEnum = exports.HttpDispatchModeBeta = exports.HttpAuthenticationTypeBeta = exports.GrantTypeBeta = void 0;
		exports.SelfImportExportDtoBetaTypeEnum = exports.SelectorTypeBeta = exports.ScheduleTypeBeta = exports.ScheduleMonthsBetaTypeEnum = exports.ScheduleHoursBetaTypeEnum = exports.ScheduleDaysBetaTypeEnum = exports.ScheduleBetaTypeEnum = exports.RoleMiningSessionStateBeta = exports.RoleMiningSessionScopingMethodBeta = exports.RoleMiningRoleTypeBeta = exports.RoleMiningPotentialRoleProvisionStateBeta = exports.RoleMiningPotentialRoleExportStateBeta = exports.RoleMembershipSelectorTypeBeta = exports.RoleInsightsResponseBetaStatusEnum = exports.RoleCriteriaOperationBeta = exports.RoleCriteriaKeyTypeBeta = exports.RoleAssignmentSourceTypeBeta = exports.ReviewerBetaTypeEnum = exports.RequestedItemStatusSodViolationContextBetaStateEnum = exports.RequestedItemStatusRequestStateBeta = exports.RequestedItemStatusPreApprovalTriggerDetailsBetaDecisionEnum = exports.RequestedItemStatusBetaTypeEnum = exports.RequestableObjectTypeBeta = exports.RequestableObjectRequestStatusBeta = exports.RequestableObjectReferenceBetaTypeEnum = exports.ReportTypeBeta = exports.ReportResultReferenceBetaStatusEnum = exports.ReportResultReferenceBetaTypeEnum = exports.ReportResultReferenceAllOfBetaStatusEnum = exports.RecommendationResponseBetaRecommendationEnum = exports.ReassignmentTypeEnumBeta = exports.ReassignmentTypeBeta = exports.ReassignReferenceBetaTypeEnum = exports.ProvisioningStateBeta = exports.ProvisioningCriteriaOperationBeta = exports.ProvisioningConfigManagedResourceRefsInnerBetaTypeEnum = exports.ProvisioningCompletedRequesterBetaTypeEnum = exports.ProvisioningCompletedRecipientBetaTypeEnum = exports.ProvisioningCompletedAccountRequestsInnerSourceBetaTypeEnum = exports.ProvisioningCompletedAccountRequestsInnerBetaProvisioningResultEnum = exports.ProvisioningCompletedAccountRequestsInnerAttributeRequestsInnerBetaOperationEnum = exports.PreApprovalTriggerDetailsBetaDecisionEnum = exports.PendingApprovalActionBeta = exports.PatchPotentialRoleRequestInnerBetaOpEnum = exports.PatOwnerBetaTypeEnum = exports.PasswordStatusBetaStateEnum = exports.PasswordChangeResponseBetaStateEnum = exports.OwnerReferenceSegmentsBetaTypeEnum = exports.OwnerReferenceDtoBetaTypeEnum = exports.OwnerReferenceBetaTypeEnum = void 0;
		exports.TemplateBulkDeleteDtoBetaMediumEnum = exports.TaskStatusMessageBetaTypeEnum = exports.TaskStatusBetaCompletionStatusEnum = exports.TaskStatusBetaTypeEnum = exports.TaskResultSimplifiedBetaCompletionStatusEnum = exports.TaskResultDtoBetaTypeEnum = exports.TaggedObjectObjectRefBetaTypeEnum = exports.TaggedObjectDtoBetaTypeEnum = exports.SubscriptionTypeBeta = exports.SubscriptionPatchRequestInnerBetaOpEnum = exports.StatusResponseBetaStatusEnum = exports.StandardLevelBeta = exports.SpConfigJobBetaTypeEnum = exports.SpConfigJobBetaStatusEnum = exports.SpConfigImportJobStatusBetaTypeEnum = exports.SpConfigImportJobStatusBetaStatusEnum = exports.SpConfigExportJobStatusBetaTypeEnum = exports.SpConfigExportJobStatusBetaStatusEnum = exports.SpConfigExportJobBetaTypeEnum = exports.SpConfigExportJobBetaStatusEnum = exports.SourceUsageStatusBetaStatusEnum = exports.SourceUpdatedActorBetaTypeEnum = exports.SourceSyncJobBetaStatusEnum = exports.SourceSchemasInnerBetaTypeEnum = exports.SourcePasswordPoliciesInnerBetaTypeEnum = exports.SourceOwnerBetaTypeEnum = exports.SourceManagerCorrelationRuleBetaTypeEnum = exports.SourceManagementWorkgroupBetaTypeEnum = exports.SourceFeatureBeta = exports.SourceDeletedActorBetaTypeEnum = exports.SourceCreatedActorBetaTypeEnum = exports.SourceClusterDtoBetaTypeEnum = exports.SourceClusterBetaTypeEnum = exports.SourceBeforeProvisioningRuleBetaTypeEnum = exports.SourceAccountCorrelationRuleBetaTypeEnum = exports.SourceAccountCorrelationConfigBetaTypeEnum = exports.SodViolationContextCheckCompletedBetaStateEnum = exports.SodViolationContextCheckCompleted1BetaStateEnum = exports.SodReportResultDtoBetaTypeEnum = exports.SodRecipientBetaTypeEnum = exports.SodPolicyDtoBetaTypeEnum = exports.SodPolicyBetaTypeEnum = exports.SodPolicyBetaStateEnum = exports.SlimcampaignBetaCorrelatedStatusEnum = exports.SlimcampaignBetaStatusEnum = exports.SlimcampaignBetaTypeEnum = exports.ServiceDeskSourceBetaTypeEnum = exports.SendTokenResponseBetaStatusEnum = exports.SendTokenRequestBetaDeliveryTypeEnum = exports.SendTestNotificationRequestDtoBetaMediumEnum = void 0;
		exports.AccountUsagesBetaApiAxiosParamCreator = exports.AccountAggregationsBetaApi = exports.AccountAggregationsBetaApiFactory = exports.AccountAggregationsBetaApiFp = exports.AccountAggregationsBetaApiAxiosParamCreator = exports.AccountActivitiesBetaApi = exports.AccountActivitiesBetaApiFactory = exports.AccountActivitiesBetaApiFp = exports.AccountActivitiesBetaApiAxiosParamCreator = exports.AccessRequestsBetaApi = exports.AccessRequestsBetaApiFactory = exports.AccessRequestsBetaApiFp = exports.AccessRequestsBetaApiAxiosParamCreator = exports.AccessRequestIdentityMetricsBetaApi = exports.AccessRequestIdentityMetricsBetaApiFactory = exports.AccessRequestIdentityMetricsBetaApiFp = exports.AccessRequestIdentityMetricsBetaApiAxiosParamCreator = exports.AccessRequestApprovalsBetaApi = exports.AccessRequestApprovalsBetaApiFactory = exports.AccessRequestApprovalsBetaApiFp = exports.AccessRequestApprovalsBetaApiAxiosParamCreator = exports.AccessProfilesBetaApi = exports.AccessProfilesBetaApiFactory = exports.AccessProfilesBetaApiFp = exports.AccessProfilesBetaApiAxiosParamCreator = exports.WorkgroupConnectionDtoBetaConnectionTypeEnum = exports.WorkflowTriggerBetaTypeEnum = exports.WorkflowLibraryTriggerBetaTypeEnum = exports.WorkflowLibraryFormFieldsBetaTypeEnum = exports.WorkflowExecutionEventBetaTypeEnum = exports.WorkflowExecutionBetaStatusEnum = exports.WorkflowBodyOwnerBetaTypeEnum = exports.WorkflowAllOfCreatorBetaTypeEnum = exports.WorkItemTypeBeta = exports.WorkItemStateBeta = exports.ViolationOwnerAssignmentConfigOwnerRefBetaTypeEnum = exports.ViolationOwnerAssignmentConfigBetaAssignmentRuleEnum = exports.ViolationContextPolicyBetaTypeEnum = exports.VerificationResponseBetaStatusEnum = exports.VAClusterStatusChangeEventPreviousHealthCheckResultBetaStatusEnum = exports.VAClusterStatusChangeEventHealthCheckResultBetaStatusEnum = exports.VAClusterStatusChangeEventBetaTypeEnum = exports.UsageTypeBeta = exports.TriggerTypeBeta = exports.TransformReadBetaTypeEnum = exports.TransformBetaTypeEnum = exports.TokenAuthResponseBetaStatusEnum = exports.TokenAuthRequestBetaDeliveryTypeEnum = exports.TemplateDtoDefaultBetaMediumEnum = exports.TemplateDtoBetaMediumEnum = void 0;
		exports.IAIMessageCatalogsBetaApiFactory = exports.IAIMessageCatalogsBetaApiFp = exports.IAIMessageCatalogsBetaApiAxiosParamCreator = exports.IAICommonAccessBetaApi = exports.IAICommonAccessBetaApiFactory = exports.IAICommonAccessBetaApiFp = exports.IAICommonAccessBetaApiAxiosParamCreator = exports.IAIAccessRequestRecommendationsBetaApi = exports.IAIAccessRequestRecommendationsBetaApiFactory = exports.IAIAccessRequestRecommendationsBetaApiFp = exports.IAIAccessRequestRecommendationsBetaApiAxiosParamCreator = exports.GovernanceGroupsBetaApi = exports.GovernanceGroupsBetaApiFactory = exports.GovernanceGroupsBetaApiFp = exports.GovernanceGroupsBetaApiAxiosParamCreator = exports.EntitlementsBetaApi = exports.EntitlementsBetaApiFactory = exports.EntitlementsBetaApiFp = exports.EntitlementsBetaApiAxiosParamCreator = exports.CustomPasswordInstructionsBetaApi = exports.CustomPasswordInstructionsBetaApiFactory = exports.CustomPasswordInstructionsBetaApiFp = exports.CustomPasswordInstructionsBetaApiAxiosParamCreator = exports.CustomFormsBetaApi = exports.CustomFormsBetaApiFactory = exports.CustomFormsBetaApiFp = exports.CustomFormsBetaApiAxiosParamCreator = exports.ConnectorsBetaApi = exports.ConnectorsBetaApiFactory = exports.ConnectorsBetaApiFp = exports.ConnectorsBetaApiAxiosParamCreator = exports.ConnectorRuleManagementBetaApi = exports.ConnectorRuleManagementBetaApiFactory = exports.ConnectorRuleManagementBetaApiFp = exports.ConnectorRuleManagementBetaApiAxiosParamCreator = exports.CertificationsBetaApi = exports.CertificationsBetaApiFactory = exports.CertificationsBetaApiFp = exports.CertificationsBetaApiAxiosParamCreator = exports.CertificationCampaignsBetaApi = exports.CertificationCampaignsBetaApiFactory = exports.CertificationCampaignsBetaApiFp = exports.CertificationCampaignsBetaApiAxiosParamCreator = exports.AccountsBetaApi = exports.AccountsBetaApiFactory = exports.AccountsBetaApiFp = exports.AccountsBetaApiAxiosParamCreator = exports.AccountUsagesBetaApi = exports.AccountUsagesBetaApiFactory = exports.AccountUsagesBetaApiFp = void 0;
		exports.ManagedClustersBetaApiAxiosParamCreator = exports.ManagedClientsBetaApi = exports.ManagedClientsBetaApiFactory = exports.ManagedClientsBetaApiFp = exports.ManagedClientsBetaApiAxiosParamCreator = exports.MFAControllerBetaApi = exports.MFAControllerBetaApiFactory = exports.MFAControllerBetaApiFp = exports.MFAControllerBetaApiAxiosParamCreator = exports.MFAConfigurationBetaApi = exports.MFAConfigurationBetaApiFactory = exports.MFAConfigurationBetaApiFp = exports.MFAConfigurationBetaApiAxiosParamCreator = exports.LifecycleStatesBetaApi = exports.LifecycleStatesBetaApiFactory = exports.LifecycleStatesBetaApiFp = exports.LifecycleStatesBetaApiAxiosParamCreator = exports.IdentityProfilesBetaApi = exports.IdentityProfilesBetaApiFactory = exports.IdentityProfilesBetaApiFp = exports.IdentityProfilesBetaApiAxiosParamCreator = exports.IdentityHistoryBetaApi = exports.IdentityHistoryBetaApiFactory = exports.IdentityHistoryBetaApiFp = exports.IdentityHistoryBetaApiAxiosParamCreator = exports.IdentityAttributesBetaApi = exports.IdentityAttributesBetaApiFactory = exports.IdentityAttributesBetaApiFp = exports.IdentityAttributesBetaApiAxiosParamCreator = exports.IdentitiesBetaApi = exports.IdentitiesBetaApiFactory = exports.IdentitiesBetaApiFp = exports.IdentitiesBetaApiAxiosParamCreator = exports.IAIRoleMiningBetaApi = exports.IAIRoleMiningBetaApiFactory = exports.IAIRoleMiningBetaApiFp = exports.IAIRoleMiningBetaApiAxiosParamCreator = exports.IAIRecommendationsBetaApi = exports.IAIRecommendationsBetaApiFactory = exports.IAIRecommendationsBetaApiFp = exports.IAIRecommendationsBetaApiAxiosParamCreator = exports.IAIPeerGroupStrategiesBetaApi = exports.IAIPeerGroupStrategiesBetaApiFactory = exports.IAIPeerGroupStrategiesBetaApiFp = exports.IAIPeerGroupStrategiesBetaApiAxiosParamCreator = exports.IAIOutliersBetaApi = exports.IAIOutliersBetaApiFactory = exports.IAIOutliersBetaApiFp = exports.IAIOutliersBetaApiAxiosParamCreator = exports.IAIMessageCatalogsBetaApi = void 0;
		exports.RoleInsightsBetaApiFactory = exports.RoleInsightsBetaApiFp = exports.RoleInsightsBetaApiAxiosParamCreator = exports.RequestableObjectsBetaApi = exports.RequestableObjectsBetaApiFactory = exports.RequestableObjectsBetaApiFp = exports.RequestableObjectsBetaApiAxiosParamCreator = exports.PublicIdentitiesConfigBetaApi = exports.PublicIdentitiesConfigBetaApiFactory = exports.PublicIdentitiesConfigBetaApiFp = exports.PublicIdentitiesConfigBetaApiAxiosParamCreator = exports.PersonalAccessTokensBetaApi = exports.PersonalAccessTokensBetaApiFactory = exports.PersonalAccessTokensBetaApiFp = exports.PersonalAccessTokensBetaApiAxiosParamCreator = exports.PasswordSyncGroupsBetaApi = exports.PasswordSyncGroupsBetaApiFactory = exports.PasswordSyncGroupsBetaApiFp = exports.PasswordSyncGroupsBetaApiAxiosParamCreator = exports.PasswordManagementBetaApi = exports.PasswordManagementBetaApiFactory = exports.PasswordManagementBetaApiFp = exports.PasswordManagementBetaApiAxiosParamCreator = exports.PasswordDictionaryBetaApi = exports.PasswordDictionaryBetaApiFactory = exports.PasswordDictionaryBetaApiFp = exports.PasswordDictionaryBetaApiAxiosParamCreator = exports.PasswordConfigurationBetaApi = exports.PasswordConfigurationBetaApiFactory = exports.PasswordConfigurationBetaApiFp = exports.PasswordConfigurationBetaApiAxiosParamCreator = exports.OrgConfigBetaApi = exports.OrgConfigBetaApiFactory = exports.OrgConfigBetaApiFp = exports.OrgConfigBetaApiAxiosParamCreator = exports.OAuthClientsBetaApi = exports.OAuthClientsBetaApiFactory = exports.OAuthClientsBetaApiFp = exports.OAuthClientsBetaApiAxiosParamCreator = exports.NotificationsBetaApi = exports.NotificationsBetaApiFactory = exports.NotificationsBetaApiFp = exports.NotificationsBetaApiAxiosParamCreator = exports.NonEmployeeLifecycleManagementBetaApi = exports.NonEmployeeLifecycleManagementBetaApiFactory = exports.NonEmployeeLifecycleManagementBetaApiFp = exports.NonEmployeeLifecycleManagementBetaApiAxiosParamCreator = exports.ManagedClustersBetaApi = exports.ManagedClustersBetaApiFactory = exports.ManagedClustersBetaApiFp = void 0;
		exports.TriggersBetaApiAxiosParamCreator = exports.TransformsBetaApi = exports.TransformsBetaApiFactory = exports.TransformsBetaApiFp = exports.TransformsBetaApiAxiosParamCreator = exports.TaskManagementBetaApi = exports.TaskManagementBetaApiFactory = exports.TaskManagementBetaApiFp = exports.TaskManagementBetaApiAxiosParamCreator = exports.TaggedObjectsBetaApi = exports.TaggedObjectsBetaApiFactory = exports.TaggedObjectsBetaApiFp = exports.TaggedObjectsBetaApiAxiosParamCreator = exports.SourcesBetaApi = exports.SourcesBetaApiFactory = exports.SourcesBetaApiFp = exports.SourcesBetaApiAxiosParamCreator = exports.SourceUsagesBetaApi = exports.SourceUsagesBetaApiFactory = exports.SourceUsagesBetaApiFp = exports.SourceUsagesBetaApiAxiosParamCreator = exports.ServiceDeskIntegrationBetaApi = exports.ServiceDeskIntegrationBetaApiFactory = exports.ServiceDeskIntegrationBetaApiFp = exports.ServiceDeskIntegrationBetaApiAxiosParamCreator = exports.SegmentsBetaApi = exports.SegmentsBetaApiFactory = exports.SegmentsBetaApiFp = exports.SegmentsBetaApiAxiosParamCreator = exports.SearchAttributeConfigurationBetaApi = exports.SearchAttributeConfigurationBetaApiFactory = exports.SearchAttributeConfigurationBetaApiFp = exports.SearchAttributeConfigurationBetaApiAxiosParamCreator = exports.SPConfigBetaApi = exports.SPConfigBetaApiFactory = exports.SPConfigBetaApiFp = exports.SPConfigBetaApiAxiosParamCreator = exports.SODViolationsBetaApi = exports.SODViolationsBetaApiFactory = exports.SODViolationsBetaApiFp = exports.SODViolationsBetaApiAxiosParamCreator = exports.SODPolicyBetaApi = exports.SODPolicyBetaApiFactory = exports.SODPolicyBetaApiFp = exports.SODPolicyBetaApiAxiosParamCreator = exports.RolesBetaApi = exports.RolesBetaApiFactory = exports.RolesBetaApiFp = exports.RolesBetaApiAxiosParamCreator = exports.RoleInsightsBetaApi = void 0;
		exports.WorkflowsBetaApi = exports.WorkflowsBetaApiFactory = exports.WorkflowsBetaApiFp = exports.WorkflowsBetaApiAxiosParamCreator = exports.WorkReassignmentBetaApi = exports.WorkReassignmentBetaApiFactory = exports.WorkReassignmentBetaApiFp = exports.WorkReassignmentBetaApiAxiosParamCreator = exports.WorkItemsBetaApi = exports.WorkItemsBetaApiFactory = exports.WorkItemsBetaApiFp = exports.WorkItemsBetaApiAxiosParamCreator = exports.TriggersBetaApi = exports.TriggersBetaApiFactory = exports.TriggersBetaApiFp = void 0;
		var axios_1 = __importDefault(requireAxios());
		// Some imports not used depending on template conditions
		// @ts-ignore
		var common_1 = requireCommon$2();
		// @ts-ignore
		var base_1 = requireBase$1();
		exports.AccessConstraintBetaTypeEnum = {
		    Entitlement: 'ENTITLEMENT',
		    AccessProfile: 'ACCESS_PROFILE',
		    Role: 'ROLE'
		};
		exports.AccessConstraintBetaOperatorEnum = {
		    All: 'ALL',
		    Selected: 'SELECTED'
		};
		exports.AccessCriteriaCriteriaListInnerBetaTypeEnum = {
		    Entitlement: 'ENTITLEMENT'
		};
		exports.AccessItemApproverDtoBetaTypeEnum = {
		    Identity: 'IDENTITY'
		};
		exports.AccessItemDiffBetaEventTypeEnum = {
		    Add: 'ADD',
		    Remove: 'REMOVE'
		};
		exports.AccessItemOwnerDtoBetaTypeEnum = {
		    Identity: 'IDENTITY'
		};
		exports.AccessItemRefBetaTypeEnum = {
		    Entitlement: 'ENTITLEMENT',
		    AccessProfile: 'ACCESS_PROFILE',
		    Role: 'ROLE'
		};
		exports.AccessItemRequestedForBetaTypeEnum = {
		    Identity: 'IDENTITY'
		};
		exports.AccessItemRequestedForDtoBetaTypeEnum = {
		    Identity: 'IDENTITY'
		};
		exports.AccessItemRequesterBetaTypeEnum = {
		    Identity: 'IDENTITY'
		};
		exports.AccessItemRequesterDtoBetaTypeEnum = {
		    Identity: 'IDENTITY'
		};
		exports.AccessItemReviewedByBetaTypeEnum = {
		    Identity: 'IDENTITY'
		};
		exports.AccessProfileApprovalSchemeBetaApproverTypeEnum = {
		    AppOwner: 'APP_OWNER',
		    Owner: 'OWNER',
		    SourceOwner: 'SOURCE_OWNER',
		    Manager: 'MANAGER',
		    GovernanceGroup: 'GOVERNANCE_GROUP'
		};
		exports.AccessProfileRefBetaTypeEnum = {
		    AccessProfile: 'ACCESS_PROFILE'
		};
		exports.AccessProfileSourceRefBetaTypeEnum = {
		    Source: 'SOURCE'
		};
		exports.AccessProfileUsageUsedByInnerBetaTypeEnum = {
		    Role: 'ROLE'
		};
		exports.AccessRequestDynamicApprover1BetaTypeEnum = {
		    Identity: 'IDENTITY',
		    GovernanceGroup: 'GOVERNANCE_GROUP'
		};
		exports.AccessRequestDynamicApproverRequestedByBetaTypeEnum = {
		    Identity: 'IDENTITY'
		};
		exports.AccessRequestDynamicApproverRequestedItemsInnerBetaTypeEnum = {
		    AccessProfile: 'ACCESS_PROFILE',
		    Role: 'ROLE',
		    Entitlement: 'ENTITLEMENT'
		};
		exports.AccessRequestDynamicApproverRequestedItemsInnerBetaOperationEnum = {
		    Add: 'Add',
		    Remove: 'Remove'
		};
		exports.AccessRequestItemBetaTypeEnum = {
		    AccessProfile: 'ACCESS_PROFILE',
		    Role: 'ROLE',
		    Entitlement: 'ENTITLEMENT'
		};
		exports.AccessRequestItemResponseBetaDecisionEnum = {
		    Approved: 'APPROVED',
		    Rejected: 'REJECTED'
		};
		exports.AccessRequestPhasesBetaStateEnum = {
		    Pending: 'PENDING',
		    Executing: 'EXECUTING',
		    Completed: 'COMPLETED',
		    Cancelled: 'CANCELLED',
		    NotExecuted: 'NOT_EXECUTED'
		};
		exports.AccessRequestPhasesBetaResultEnum = {
		    Successful: 'SUCCESSFUL',
		    Failed: 'FAILED',
		    Null: 'null'
		};
		exports.AccessRequestPostApprovalRequestedByBetaTypeEnum = {
		    Identity: 'IDENTITY'
		};
		exports.AccessRequestPostApprovalRequestedItemsStatusInnerApprovalInfoInnerApproverBetaTypeEnum = {
		    Identity: 'IDENTITY'
		};
		exports.AccessRequestPostApprovalRequestedItemsStatusInnerApprovalInfoInnerBetaApprovalDecisionEnum = {
		    Approved: 'APPROVED',
		    Denied: 'DENIED'
		};
		exports.AccessRequestPostApprovalRequestedItemsStatusInnerBetaTypeEnum = {
		    AccessProfile: 'ACCESS_PROFILE',
		    Role: 'ROLE',
		    Entitlement: 'ENTITLEMENT'
		};
		exports.AccessRequestPostApprovalRequestedItemsStatusInnerBetaOperationEnum = {
		    Add: 'Add',
		    Remove: 'Remove'
		};
		exports.AccessRequestPreApprovalRequestedItemsInnerBetaTypeEnum = {
		    AccessProfile: 'ACCESS_PROFILE',
		    Role: 'ROLE',
		    Entitlement: 'ENTITLEMENT'
		};
		exports.AccessRequestPreApprovalRequestedItemsInnerBetaOperationEnum = {
		    Add: 'Add',
		    Remove: 'Remove'
		};
		/**
		 * The type of access item.
		 * @export
		 * @enum {string}
		 */
		exports.AccessRequestRecommendationItemTypeBeta = {
		    AccessProfile: 'ACCESS_PROFILE',
		    Role: 'ROLE'
		};
		/**
		 * Access request type. Defaults to GRANT_ACCESS. REVOKE_ACCESS type can only have a single Identity ID in the requestedFor field.
		 * @export
		 * @enum {string}
		 */
		exports.AccessRequestTypeBeta = {
		    GrantAccess: 'GRANT_ACCESS',
		    RevokeAccess: 'REVOKE_ACCESS',
		    Null: 'null'
		};
		/**
		 * Access type of API Client indicating online or offline use
		 * @export
		 * @enum {string}
		 */
		exports.AccessTypeBeta = {
		    Online: 'ONLINE',
		    Offline: 'OFFLINE'
		};
		exports.AccountActionBetaActionEnum = {
		    Enable: 'ENABLE',
		    Disable: 'DISABLE'
		};
		/**
		 * Represents an operation in an account activity item
		 * @export
		 * @enum {string}
		 */
		exports.AccountActivityItemOperationBeta = {
		    Add: 'ADD',
		    Create: 'CREATE',
		    Modify: 'MODIFY',
		    Delete: 'DELETE',
		    Disable: 'DISABLE',
		    Enable: 'ENABLE',
		    Unlock: 'UNLOCK',
		    Lock: 'LOCK',
		    Remove: 'REMOVE',
		    Set: 'SET',
		    Null: 'null'
		};
		exports.AccountAggregationBetaStatusEnum = {
		    Started: 'STARTED',
		    AccountsCollected: 'ACCOUNTS_COLLECTED',
		    Completed: 'COMPLETED',
		    Cancelled: 'CANCELLED',
		    Retried: 'RETRIED',
		    Terminated: 'TERMINATED'
		};
		exports.AccountAggregationCompletedBetaStatusEnum = {
		    Success: 'Success',
		    Failed: 'Failed',
		    Terminated: 'Terminated'
		};
		exports.AccountAggregationCompletedSourceBetaTypeEnum = {
		    Source: 'SOURCE'
		};
		exports.AccountAggregationStatusBetaStatusEnum = {
		    Started: 'STARTED',
		    AccountsCollected: 'ACCOUNTS_COLLECTED',
		    Completed: 'COMPLETED',
		    Cancelled: 'CANCELLED',
		    Retried: 'RETRIED',
		    Terminated: 'TERMINATED'
		};
		exports.AccountAttributesChangedAccountBetaTypeEnum = {
		    Account: 'ACCOUNT'
		};
		exports.AccountAttributesChangedIdentityBetaTypeEnum = {
		    Identity: 'IDENTITY'
		};
		exports.AccountAttributesChangedSourceBetaTypeEnum = {
		    Source: 'SOURCE'
		};
		exports.AccountCorrelatedAccountBetaTypeEnum = {
		    Account: 'ACCOUNT'
		};
		exports.AccountCorrelatedIdentityBetaTypeEnum = {
		    Identity: 'IDENTITY'
		};
		exports.AccountCorrelatedSourceBetaTypeEnum = {
		    Source: 'SOURCE'
		};
		exports.AccountStatusChangedStatusChangeBetaPreviousStatusEnum = {
		    Enabled: 'enabled',
		    Disabled: 'disabled',
		    Locked: 'locked'
		};
		exports.AccountStatusChangedStatusChangeBetaNewStatusEnum = {
		    Enabled: 'enabled',
		    Disabled: 'disabled',
		    Locked: 'locked'
		};
		exports.AccountUncorrelatedAccountBetaTypeEnum = {
		    Account: 'ACCOUNT'
		};
		exports.AccountUncorrelatedIdentityBetaTypeEnum = {
		    Identity: 'IDENTITY'
		};
		exports.AccountUncorrelatedSourceBetaTypeEnum = {
		    Source: 'SOURCE'
		};
		exports.AccountsCollectedForAggregationBetaStatusEnum = {
		    Success: 'Success',
		    Failed: 'Failed',
		    Terminated: 'Terminated'
		};
		exports.AccountsCollectedForAggregationSourceBetaTypeEnum = {
		    Source: 'SOURCE'
		};
		exports.AdminReviewReassignReassignToBetaTypeEnum = {
		    Identity: 'IDENTITY'
		};
		/**
		 * Describes the individual or group that is responsible for an approval step.
		 * @export
		 * @enum {string}
		 */
		exports.ApprovalSchemeBeta = {
		    AppOwner: 'APP_OWNER',
		    SourceOwner: 'SOURCE_OWNER',
		    Manager: 'MANAGER',
		    RoleOwner: 'ROLE_OWNER',
		    AccessProfileOwner: 'ACCESS_PROFILE_OWNER',
		    EntitlementOwner: 'ENTITLEMENT_OWNER',
		    GovernanceGroup: 'GOVERNANCE_GROUP'
		};
		exports.ApprovalSchemeForRoleBetaApproverTypeEnum = {
		    Owner: 'OWNER',
		    Manager: 'MANAGER',
		    GovernanceGroup: 'GOVERNANCE_GROUP'
		};
		/**
		 * Enum representing the non-employee request approval status
		 * @export
		 * @enum {string}
		 */
		exports.ApprovalStatusBeta = {
		    Approved: 'APPROVED',
		    Rejected: 'REJECTED',
		    Pending: 'PENDING',
		    NotReady: 'NOT_READY',
		    Cancelled: 'CANCELLED'
		};
		exports.ApprovalStatusDtoCurrentOwnerBetaTypeEnum = {
		    Identity: 'IDENTITY'
		};
		exports.ApprovalStatusDtoOriginalOwnerBetaTypeEnum = {
		    GovernanceGroup: 'GOVERNANCE_GROUP',
		    Identity: 'IDENTITY'
		};
		exports.AttrSyncSourceBetaTypeEnum = {
		    Source: 'SOURCE'
		};
		exports.AttributeDefinitionSchemaBetaTypeEnum = {
		    ConnectorSchema: 'CONNECTOR_SCHEMA'
		};
		/**
		 * The underlying type of the value which an AttributeDefinition represents.
		 * @export
		 * @enum {string}
		 */
		exports.AttributeDefinitionTypeBeta = {
		    String: 'STRING',
		    Long: 'LONG',
		    Int: 'INT',
		    Boolean: 'BOOLEAN'
		};
		exports.BeforeProvisioningRuleDtoBetaTypeEnum = {
		    Rule: 'RULE'
		};
		exports.BulkTaggedObjectBetaOperationEnum = {
		    Append: 'APPEND',
		    Merge: 'MERGE'
		};
		exports.BulkWorkgroupMembersRequestInnerBetaTypeEnum = {
		    Identity: 'IDENTITY'
		};
		exports.CampaignActivatedCampaignBetaTypeEnum = {
		    Manager: 'MANAGER',
		    SourceOwner: 'SOURCE_OWNER',
		    Search: 'SEARCH',
		    RoleComposition: 'ROLE_COMPOSITION'
		};
		exports.CampaignActivatedCampaignBetaStatusEnum = {
		    Active: 'ACTIVE'
		};
		exports.CampaignAlertBetaLevelEnum = {
		    Error: 'ERROR',
		    Warn: 'WARN',
		    Info: 'INFO'
		};
		exports.CampaignBetaTypeEnum = {
		    Manager: 'MANAGER',
		    SourceOwner: 'SOURCE_OWNER',
		    Search: 'SEARCH',
		    RoleComposition: 'ROLE_COMPOSITION'
		};
		exports.CampaignBetaStatusEnum = {
		    Pending: 'PENDING',
		    Staged: 'STAGED',
		    Canceling: 'CANCELING',
		    Activating: 'ACTIVATING',
		    Active: 'ACTIVE',
		    Completing: 'COMPLETING',
		    Completed: 'COMPLETED',
		    Error: 'ERROR',
		    Archived: 'ARCHIVED'
		};
		exports.CampaignBetaCorrelatedStatusEnum = {
		    Correlated: 'CORRELATED',
		    Uncorrelated: 'UNCORRELATED'
		};
		exports.CampaignBetaMandatoryCommentRequirementEnum = {
		    AllDecisions: 'ALL_DECISIONS',
		    RevokeOnlyDecisions: 'REVOKE_ONLY_DECISIONS',
		    NoDecisions: 'NO_DECISIONS'
		};
		exports.CampaignEndedCampaignBetaTypeEnum = {
		    Manager: 'MANAGER',
		    SourceOwner: 'SOURCE_OWNER',
		    Search: 'SEARCH',
		    RoleComposition: 'ROLE_COMPOSITION'
		};
		exports.CampaignEndedCampaignBetaStatusEnum = {
		    Completed: 'COMPLETED'
		};
		exports.CampaignGeneratedCampaignBetaTypeEnum = {
		    Manager: 'MANAGER',
		    SourceOwner: 'SOURCE_OWNER',
		    Search: 'SEARCH',
		    RoleComposition: 'ROLE_COMPOSITION'
		};
		exports.CampaignGeneratedCampaignBetaStatusEnum = {
		    Staged: 'STAGED',
		    Activating: 'ACTIVATING',
		    Active: 'ACTIVE'
		};
		exports.CampaignReferenceBetaTypeEnum = {
		    Campaign: 'CAMPAIGN'
		};
		exports.CampaignReferenceBetaCampaignTypeEnum = {
		    Manager: 'MANAGER',
		    SourceOwner: 'SOURCE_OWNER',
		    Search: 'SEARCH'
		};
		exports.CampaignReferenceBetaCorrelatedStatusEnum = {
		    Correlated: 'CORRELATED',
		    Uncorrelated: 'UNCORRELATED'
		};
		exports.CampaignReferenceBetaMandatoryCommentRequirementEnum = {
		    AllDecisions: 'ALL_DECISIONS',
		    RevokeOnlyDecisions: 'REVOKE_ONLY_DECISIONS',
		    NoDecisions: 'NO_DECISIONS'
		};
		exports.CampaignReportBetaTypeEnum = {
		    ReportResult: 'REPORT_RESULT'
		};
		exports.CampaignReportBetaStatusEnum = {
		    Success: 'SUCCESS',
		    Warning: 'WARNING',
		    Error: 'ERROR',
		    Terminated: 'TERMINATED',
		    TempError: 'TEMP_ERROR',
		    Pending: 'PENDING'
		};
		exports.CampaignTemplateOwnerRefBetaTypeEnum = {
		    Identity: 'IDENTITY'
		};
		/**
		 * The current phase of the campaign. * `STAGED`: The campaign is waiting to be activated. * `ACTIVE`: The campaign is active. * `SIGNED`: The reviewer has signed off on the campaign, and it is considered complete.
		 * @export
		 * @enum {string}
		 */
		exports.CertificationPhaseBeta = {
		    Staged: 'STAGED',
		    Active: 'ACTIVE',
		    Signed: 'SIGNED'
		};
		exports.CertificationReferenceBetaTypeEnum = {
		    Certification: 'CERTIFICATION'
		};
		exports.CertificationReferenceDtoBetaTypeEnum = {
		    Certification: 'CERTIFICATION'
		};
		exports.CertificationTaskBetaTypeEnum = {
		    Reassign: 'REASSIGN',
		    AdminReassign: 'ADMIN_REASSIGN',
		    CompleteCertification: 'COMPLETE_CERTIFICATION',
		    FinishCertification: 'FINISH_CERTIFICATION',
		    CompleteCampaign: 'COMPLETE_CAMPAIGN',
		    ActivateCampaign: 'ACTIVATE_CAMPAIGN',
		    CampaignCreate: 'CAMPAIGN_CREATE',
		    CampaignDelete: 'CAMPAIGN_DELETE'
		};
		exports.CertificationTaskBetaTargetTypeEnum = {
		    Certification: 'CERTIFICATION',
		    Campaign: 'CAMPAIGN'
		};
		exports.CertificationTaskBetaStatusEnum = {
		    Queued: 'QUEUED',
		    InProgress: 'IN_PROGRESS',
		    Success: 'SUCCESS',
		    Error: 'ERROR'
		};
		/**
		 * Type of an API Client indicating public or confidentials use
		 * @export
		 * @enum {string}
		 */
		exports.ClientTypeBeta = {
		    Confidential: 'CONFIDENTIAL',
		    Public: 'PUBLIC'
		};
		exports.CloseAccessRequestBetaExecutionStatusEnum = {
		    Terminated: 'Terminated',
		    Completed: 'Completed'
		};
		exports.CloseAccessRequestBetaCompletionStatusEnum = {
		    Success: 'Success',
		    Incomplete: 'Incomplete',
		    Failure: 'Failure'
		};
		exports.CommentDto1AuthorBetaTypeEnum = {
		    Identity: 'IDENTITY'
		};
		exports.CommentDtoAuthorBetaTypeEnum = {
		    Identity: 'IDENTITY'
		};
		/**
		 * State of common access item.
		 * @export
		 * @enum {string}
		 */
		exports.CommonAccessItemStateBeta = {
		    Confirmed: 'CONFIRMED',
		    Denied: 'DENIED'
		};
		/**
		 * The type of access item.
		 * @export
		 * @enum {string}
		 */
		exports.CommonAccessTypeBeta = {
		    AccessProfile: 'ACCESS_PROFILE',
		    Role: 'ROLE'
		};
		exports.CompleteCampaignOptionsBetaAutoCompleteActionEnum = {
		    Approve: 'APPROVE',
		    Revoke: 'REVOKE'
		};
		exports.CompletedApprovalReviewedByBetaTypeEnum = {
		    Identity: 'IDENTITY'
		};
		/**
		 * Enum represents completed approval object\'s state.
		 * @export
		 * @enum {string}
		 */
		exports.CompletedApprovalStateBeta = {
		    Approved: 'APPROVED',
		    Rejected: 'REJECTED'
		};
		/**
		 * The status after completion.
		 * @export
		 * @enum {string}
		 */
		exports.CompletionStatusBeta = {
		    Success: 'SUCCESS',
		    Failure: 'FAILURE',
		    Incomplete: 'INCOMPLETE',
		    Pending: 'PENDING',
		    Null: 'null'
		};
		exports.ConditionEffectBetaEffectTypeEnum = {
		    Hide: 'HIDE',
		    Show: 'SHOW',
		    Disable: 'DISABLE',
		    Enable: 'ENABLE',
		    Require: 'REQUIRE',
		    Optional: 'OPTIONAL',
		    SubmitMessage: 'SUBMIT_MESSAGE',
		    SubmitNotification: 'SUBMIT_NOTIFICATION',
		    SetDefaultValue: 'SET_DEFAULT_VALUE'
		};
		exports.ConditionRuleBetaSourceTypeEnum = {
		    Input: 'INPUT',
		    Element: 'ELEMENT'
		};
		exports.ConditionRuleBetaOperatorEnum = {
		    Eq: 'EQ',
		    Ne: 'NE',
		    Co: 'CO',
		    NotCo: 'NOT_CO',
		    In: 'IN',
		    NotIn: 'NOT_IN',
		    Em: 'EM',
		    NotEm: 'NOT_EM',
		    Sw: 'SW',
		    NotSw: 'NOT_SW',
		    Ew: 'EW',
		    NotEw: 'NOT_EW'
		};
		exports.ConditionRuleBetaValueTypeEnum = {
		    String: 'STRING',
		    StringList: 'STRING_LIST',
		    Input: 'INPUT',
		    Element: 'ELEMENT',
		    List: 'LIST',
		    Boolean: 'BOOLEAN'
		};
		/**
		 * Enum list of valid work types that can be selected for a Reassignment Configuration
		 * @export
		 * @enum {string}
		 */
		exports.ConfigTypeEnumBeta = {
		    AccessRequests: 'ACCESS_REQUESTS',
		    Certifications: 'CERTIFICATIONS',
		    ManualTasks: 'MANUAL_TASKS'
		};
		/**
		 * Enum list of valid work types that can be selected for a Reassignment Configuration
		 * @export
		 * @enum {string}
		 */
		exports.ConfigTypeEnumCamelBeta = {
		    AccessRequests: 'accessRequests',
		    Certifications: 'certifications',
		    ManualTasks: 'manualTasks'
		};
		/**
		 * An enumeration of the types of Objects associated with a Governance Group. Supported object types are ACCESS_PROFILE, ROLE, SOD_POLICY and SOURCE.
		 * @export
		 * @enum {string}
		 */
		exports.ConnectedObjectTypeBeta = {
		    AccessProfile: 'ACCESS_PROFILE',
		    Role: 'ROLE',
		    SodPolicy: 'SOD_POLICY',
		    Source: 'SOURCE'
		};
		exports.ConnectorRuleCreateRequestBetaTypeEnum = {
		    BuildMap: 'BuildMap',
		    ConnectorAfterCreate: 'ConnectorAfterCreate',
		    ConnectorAfterDelete: 'ConnectorAfterDelete',
		    ConnectorAfterModify: 'ConnectorAfterModify',
		    ConnectorBeforeCreate: 'ConnectorBeforeCreate',
		    ConnectorBeforeDelete: 'ConnectorBeforeDelete',
		    ConnectorBeforeModify: 'ConnectorBeforeModify',
		    JdbcBuildMap: 'JDBCBuildMap',
		    JdbcOperationProvisioning: 'JDBCOperationProvisioning',
		    JdbcProvision: 'JDBCProvision',
		    PeopleSoftHrmsBuildMap: 'PeopleSoftHRMSBuildMap',
		    PeopleSoftHrmsOperationProvisioning: 'PeopleSoftHRMSOperationProvisioning',
		    PeopleSoftHrmsProvision: 'PeopleSoftHRMSProvision',
		    RacfPermissionCustomization: 'RACFPermissionCustomization',
		    SapBuildMap: 'SAPBuildMap',
		    SapHrManagerRule: 'SapHrManagerRule',
		    SapHrOperationProvisioning: 'SapHrOperationProvisioning',
		    SapHrProvision: 'SapHrProvision',
		    SuccessFactorsOperationProvisioning: 'SuccessFactorsOperationProvisioning',
		    WebServiceAfterOperationRule: 'WebServiceAfterOperationRule',
		    WebServiceBeforeOperationRule: 'WebServiceBeforeOperationRule'
		};
		exports.ConnectorRuleResponseBetaTypeEnum = {
		    BuildMap: 'BuildMap',
		    ConnectorAfterCreate: 'ConnectorAfterCreate',
		    ConnectorAfterDelete: 'ConnectorAfterDelete',
		    ConnectorAfterModify: 'ConnectorAfterModify',
		    ConnectorBeforeCreate: 'ConnectorBeforeCreate',
		    ConnectorBeforeDelete: 'ConnectorBeforeDelete',
		    ConnectorBeforeModify: 'ConnectorBeforeModify',
		    JdbcBuildMap: 'JDBCBuildMap',
		    JdbcOperationProvisioning: 'JDBCOperationProvisioning',
		    JdbcProvision: 'JDBCProvision',
		    PeopleSoftHrmsBuildMap: 'PeopleSoftHRMSBuildMap',
		    PeopleSoftHrmsOperationProvisioning: 'PeopleSoftHRMSOperationProvisioning',
		    PeopleSoftHrmsProvision: 'PeopleSoftHRMSProvision',
		    RacfPermissionCustomization: 'RACFPermissionCustomization',
		    SapBuildMap: 'SAPBuildMap',
		    SapHrManagerRule: 'SapHrManagerRule',
		    SapHrOperationProvisioning: 'SapHrOperationProvisioning',
		    SapHrProvision: 'SapHrProvision',
		    SuccessFactorsOperationProvisioning: 'SuccessFactorsOperationProvisioning',
		    WebServiceAfterOperationRule: 'WebServiceAfterOperationRule',
		    WebServiceBeforeOperationRule: 'WebServiceBeforeOperationRule'
		};
		exports.ConnectorRuleUpdateRequestBetaTypeEnum = {
		    BuildMap: 'BuildMap',
		    ConnectorAfterCreate: 'ConnectorAfterCreate',
		    ConnectorAfterDelete: 'ConnectorAfterDelete',
		    ConnectorAfterModify: 'ConnectorAfterModify',
		    ConnectorBeforeCreate: 'ConnectorBeforeCreate',
		    ConnectorBeforeDelete: 'ConnectorBeforeDelete',
		    ConnectorBeforeModify: 'ConnectorBeforeModify',
		    JdbcBuildMap: 'JDBCBuildMap',
		    JdbcOperationProvisioning: 'JDBCOperationProvisioning',
		    JdbcProvision: 'JDBCProvision',
		    PeopleSoftHrmsBuildMap: 'PeopleSoftHRMSBuildMap',
		    PeopleSoftHrmsOperationProvisioning: 'PeopleSoftHRMSOperationProvisioning',
		    PeopleSoftHrmsProvision: 'PeopleSoftHRMSProvision',
		    RacfPermissionCustomization: 'RACFPermissionCustomization',
		    SapBuildMap: 'SAPBuildMap',
		    SapHrManagerRule: 'SapHrManagerRule',
		    SapHrOperationProvisioning: 'SapHrOperationProvisioning',
		    SapHrProvision: 'SapHrProvision',
		    SuccessFactorsOperationProvisioning: 'SuccessFactorsOperationProvisioning',
		    WebServiceAfterOperationRule: 'WebServiceAfterOperationRule',
		    WebServiceBeforeOperationRule: 'WebServiceBeforeOperationRule'
		};
		exports.ConnectorRuleValidationResponseBetaStateEnum = {
		    Ok: 'OK',
		    Error: 'ERROR'
		};
		exports.CorrelatedGovernanceEventBetaTypeEnum = {
		    Certification: 'certification',
		    AccessRequest: 'accessRequest'
		};
		exports.CreateFormInstanceRequestBetaStateEnum = {
		    Assigned: 'ASSIGNED',
		    InProgress: 'IN_PROGRESS',
		    Submitted: 'SUBMITTED',
		    Completed: 'COMPLETED',
		    Cancelled: 'CANCELLED'
		};
		exports.CustomPasswordInstructionBetaPageIdEnum = {
		    ChangePasswordenterPassword: 'change-password:enter-password',
		    ChangePasswordfinish: 'change-password:finish',
		    FlowSelectionselect: 'flow-selection:select',
		    ForgetUsernameuserEmail: 'forget-username:user-email',
		    MfaenterCode: 'mfa:enter-code',
		    MfaenterKba: 'mfa:enter-kba',
		    Mfaselect: 'mfa:select',
		    ResetPasswordenterPassword: 'reset-password:enter-password',
		    ResetPasswordenterUsername: 'reset-password:enter-username',
		    ResetPasswordfinish: 'reset-password:finish',
		    UnlockAccountenterUsername: 'unlock-account:enter-username',
		    UnlockAccountfinish: 'unlock-account:finish'
		};
		exports.DateCompareBetaOperatorEnum = {
		    Lt: 'LT',
		    Lte: 'LTE',
		    Gt: 'GT',
		    Gte: 'GTE'
		};
		exports.Delete202ResponseBetaTypeEnum = {
		    TaskResult: 'TASK_RESULT'
		};
		/**
		 * An enumeration of the types of DTOs supported within the IdentityNow infrastructure.
		 * @export
		 * @enum {string}
		 */
		exports.DtoTypeBeta = {
		    AccountCorrelationConfig: 'ACCOUNT_CORRELATION_CONFIG',
		    AccessProfile: 'ACCESS_PROFILE',
		    AccessRequestApproval: 'ACCESS_REQUEST_APPROVAL',
		    Account: 'ACCOUNT',
		    Application: 'APPLICATION',
		    Campaign: 'CAMPAIGN',
		    CampaignFilter: 'CAMPAIGN_FILTER',
		    Certification: 'CERTIFICATION',
		    Cluster: 'CLUSTER',
		    ConnectorSchema: 'CONNECTOR_SCHEMA',
		    Entitlement: 'ENTITLEMENT',
		    GovernanceGroup: 'GOVERNANCE_GROUP',
		    Identity: 'IDENTITY',
		    IdentityProfile: 'IDENTITY_PROFILE',
		    IdentityRequest: 'IDENTITY_REQUEST',
		    LifecycleState: 'LIFECYCLE_STATE',
		    PasswordPolicy: 'PASSWORD_POLICY',
		    Role: 'ROLE',
		    Rule: 'RULE',
		    SodPolicy: 'SOD_POLICY',
		    Source: 'SOURCE',
		    Tag: 'TAG',
		    TagCategory: 'TAG_CATEGORY',
		    TaskResult: 'TASK_RESULT',
		    ReportResult: 'REPORT_RESULT',
		    SodViolation: 'SOD_VIOLATION',
		    AccountActivity: 'ACCOUNT_ACTIVITY',
		    Workgroup: 'WORKGROUP'
		};
		exports.EmailStatusDtoBetaVerificationStatusEnum = {
		    Pending: 'PENDING',
		    Success: 'SUCCESS',
		    Failed: 'FAILED'
		};
		exports.EntitlementApprovalSchemeBetaApproverTypeEnum = {
		    EntitlementOwner: 'ENTITLEMENT_OWNER',
		    SourceOwner: 'SOURCE_OWNER',
		    Manager: 'MANAGER',
		    GovernanceGroup: 'GOVERNANCE_GROUP'
		};
		exports.EntitlementOwnerBetaTypeEnum = {
		    Identity: 'IDENTITY'
		};
		exports.EntitlementRefBetaTypeEnum = {
		    Entitlement: 'ENTITLEMENT'
		};
		exports.ExceptionCriteriaCriteriaListInnerBetaTypeEnum = {
		    Entitlement: 'ENTITLEMENT'
		};
		/**
		 * The current state of execution.
		 * @export
		 * @enum {string}
		 */
		exports.ExecutionStatusBeta = {
		    Executing: 'EXECUTING',
		    Verifying: 'VERIFYING',
		    Terminated: 'TERMINATED',
		    Completed: 'COMPLETED'
		};
		exports.ExportOptionsBetaExcludeTypesEnum = {
		    AccessProfile: 'ACCESS_PROFILE',
		    AccessRequestConfig: 'ACCESS_REQUEST_CONFIG',
		    AttrSyncSourceConfig: 'ATTR_SYNC_SOURCE_CONFIG',
		    AuthOrg: 'AUTH_ORG',
		    CampaignFilter: 'CAMPAIGN_FILTER',
		    FormDefinition: 'FORM_DEFINITION',
		    GovernanceGroup: 'GOVERNANCE_GROUP',
		    IdentityObjectConfig: 'IDENTITY_OBJECT_CONFIG',
		    IdentityProfile: 'IDENTITY_PROFILE',
		    LifecycleState: 'LIFECYCLE_STATE',
		    NotificationTemplate: 'NOTIFICATION_TEMPLATE',
		    PasswordPolicy: 'PASSWORD_POLICY',
		    PasswordSyncGroup: 'PASSWORD_SYNC_GROUP',
		    PublicIdentitiesConfig: 'PUBLIC_IDENTITIES_CONFIG',
		    Role: 'ROLE',
		    Rule: 'RULE',
		    Segment: 'SEGMENT',
		    ServiceDeskIntegration: 'SERVICE_DESK_INTEGRATION',
		    SodPolicy: 'SOD_POLICY',
		    Source: 'SOURCE',
		    Tag: 'TAG',
		    Transform: 'TRANSFORM',
		    TriggerSubscription: 'TRIGGER_SUBSCRIPTION',
		    Workflow: 'WORKFLOW'
		};
		exports.ExportOptionsBetaIncludeTypesEnum = {
		    AccessProfile: 'ACCESS_PROFILE',
		    AccessRequestConfig: 'ACCESS_REQUEST_CONFIG',
		    AttrSyncSourceConfig: 'ATTR_SYNC_SOURCE_CONFIG',
		    AuthOrg: 'AUTH_ORG',
		    CampaignFilter: 'CAMPAIGN_FILTER',
		    FormDefinition: 'FORM_DEFINITION',
		    GovernanceGroup: 'GOVERNANCE_GROUP',
		    IdentityObjectConfig: 'IDENTITY_OBJECT_CONFIG',
		    IdentityProfile: 'IDENTITY_PROFILE',
		    LifecycleState: 'LIFECYCLE_STATE',
		    NotificationTemplate: 'NOTIFICATION_TEMPLATE',
		    PasswordPolicy: 'PASSWORD_POLICY',
		    PasswordSyncGroup: 'PASSWORD_SYNC_GROUP',
		    PublicIdentitiesConfig: 'PUBLIC_IDENTITIES_CONFIG',
		    Role: 'ROLE',
		    Rule: 'RULE',
		    Segment: 'SEGMENT',
		    ServiceDeskIntegration: 'SERVICE_DESK_INTEGRATION',
		    SodPolicy: 'SOD_POLICY',
		    Source: 'SOURCE',
		    Tag: 'TAG',
		    Transform: 'TRANSFORM',
		    TriggerSubscription: 'TRIGGER_SUBSCRIPTION',
		    Workflow: 'WORKFLOW'
		};
		exports.ExportPayloadBetaExcludeTypesEnum = {
		    AccessProfile: 'ACCESS_PROFILE',
		    AccessRequestConfig: 'ACCESS_REQUEST_CONFIG',
		    AttrSyncSourceConfig: 'ATTR_SYNC_SOURCE_CONFIG',
		    AuthOrg: 'AUTH_ORG',
		    CampaignFilter: 'CAMPAIGN_FILTER',
		    FormDefinition: 'FORM_DEFINITION',
		    GovernanceGroup: 'GOVERNANCE_GROUP',
		    IdentityObjectConfig: 'IDENTITY_OBJECT_CONFIG',
		    IdentityProfile: 'IDENTITY_PROFILE',
		    LifecycleState: 'LIFECYCLE_STATE',
		    NotificationTemplate: 'NOTIFICATION_TEMPLATE',
		    PasswordPolicy: 'PASSWORD_POLICY',
		    PasswordSyncGroup: 'PASSWORD_SYNC_GROUP',
		    PublicIdentitiesConfig: 'PUBLIC_IDENTITIES_CONFIG',
		    Role: 'ROLE',
		    Rule: 'RULE',
		    Segment: 'SEGMENT',
		    ServiceDeskIntegration: 'SERVICE_DESK_INTEGRATION',
		    SodPolicy: 'SOD_POLICY',
		    Source: 'SOURCE',
		    Tag: 'TAG',
		    Transform: 'TRANSFORM',
		    TriggerSubscription: 'TRIGGER_SUBSCRIPTION',
		    Workflow: 'WORKFLOW'
		};
		exports.ExportPayloadBetaIncludeTypesEnum = {
		    AccessProfile: 'ACCESS_PROFILE',
		    AccessRequestConfig: 'ACCESS_REQUEST_CONFIG',
		    AttrSyncSourceConfig: 'ATTR_SYNC_SOURCE_CONFIG',
		    AuthOrg: 'AUTH_ORG',
		    CampaignFilter: 'CAMPAIGN_FILTER',
		    FormDefinition: 'FORM_DEFINITION',
		    GovernanceGroup: 'GOVERNANCE_GROUP',
		    IdentityObjectConfig: 'IDENTITY_OBJECT_CONFIG',
		    IdentityProfile: 'IDENTITY_PROFILE',
		    LifecycleState: 'LIFECYCLE_STATE',
		    NotificationTemplate: 'NOTIFICATION_TEMPLATE',
		    PasswordPolicy: 'PASSWORD_POLICY',
		    PasswordSyncGroup: 'PASSWORD_SYNC_GROUP',
		    PublicIdentitiesConfig: 'PUBLIC_IDENTITIES_CONFIG',
		    Role: 'ROLE',
		    Rule: 'RULE',
		    Segment: 'SEGMENT',
		    ServiceDeskIntegration: 'SERVICE_DESK_INTEGRATION',
		    SodPolicy: 'SOD_POLICY',
		    Source: 'SOURCE',
		    Tag: 'TAG',
		    Transform: 'TRANSFORM',
		    TriggerSubscription: 'TRIGGER_SUBSCRIPTION',
		    Workflow: 'WORKFLOW'
		};
		exports.ExpressionBetaOperatorEnum = {
		    And: 'AND',
		    Equals: 'EQUALS'
		};
		exports.FormConditionBetaRuleOperatorEnum = {
		    And: 'AND',
		    Or: 'OR'
		};
		exports.FormDefinitionInputBetaTypeEnum = {
		    String: 'STRING'
		};
		exports.FormElementBetaElementTypeEnum = {
		    Text: 'TEXT',
		    Toggle: 'TOGGLE',
		    Textarea: 'TEXTAREA',
		    Hidden: 'HIDDEN',
		    Phone: 'PHONE',
		    Email: 'EMAIL',
		    Select: 'SELECT',
		    Date: 'DATE',
		    Section: 'SECTION',
		    Columns: 'COLUMNS'
		};
		exports.FormElementDynamicDataSourceBetaDataSourceTypeEnum = {
		    Static: 'STATIC',
		    Internal: 'INTERNAL',
		    Search: 'SEARCH'
		};
		exports.FormElementDynamicDataSourceConfigBetaIndicesEnum = {
		    Accessprofiles: 'accessprofiles',
		    Accountactivities: 'accountactivities',
		    Entitlements: 'entitlements',
		    Identities: 'identities',
		    Events: 'events',
		    Roles: 'roles',
		    Star: '*'
		};
		exports.FormElementDynamicDataSourceConfigBetaObjectTypeEnum = {
		    Identity: 'IDENTITY',
		    AccessProfile: 'ACCESS_PROFILE',
		    Sources: 'SOURCES',
		    Role: 'ROLE',
		    Entitlement: 'ENTITLEMENT'
		};
		exports.FormInstanceCreatedByBetaTypeEnum = {
		    WorkflowExecution: 'WORKFLOW_EXECUTION',
		    Source: 'SOURCE'
		};
		exports.FormInstanceRecipientBetaTypeEnum = {
		    Identity: 'IDENTITY'
		};
		exports.FormInstanceResponseBetaStateEnum = {
		    Assigned: 'ASSIGNED',
		    InProgress: 'IN_PROGRESS',
		    Submitted: 'SUBMITTED',
		    Completed: 'COMPLETED',
		    Cancelled: 'CANCELLED'
		};
		exports.FormOwnerBetaTypeEnum = {
		    Identity: 'IDENTITY'
		};
		exports.FormUsedByBetaTypeEnum = {
		    Workflow: 'WORKFLOW',
		    Source: 'SOURCE'
		};
		exports.FullcampaignAllOfBetaCorrelatedStatusEnum = {
		    Correlated: 'CORRELATED',
		    Uncorrelated: 'UNCORRELATED'
		};
		exports.FullcampaignAllOfBetaMandatoryCommentRequirementEnum = {
		    AllDecisions: 'ALL_DECISIONS',
		    RevokeOnlyDecisions: 'REVOKE_ONLY_DECISIONS',
		    NoDecisions: 'NO_DECISIONS'
		};
		exports.FullcampaignAllOfFilterBetaTypeEnum = {
		    CampaignFilter: 'CAMPAIGN_FILTER',
		    Rule: 'RULE'
		};
		exports.FullcampaignAllOfRoleCompositionCampaignInfoRemediatorRefBetaTypeEnum = {
		    Identity: 'IDENTITY'
		};
		exports.FullcampaignAllOfSearchCampaignInfoBetaTypeEnum = {
		    Identity: 'IDENTITY',
		    Access: 'ACCESS'
		};
		exports.FullcampaignAllOfSearchCampaignInfoReviewerBetaTypeEnum = {
		    GovernanceGroup: 'GOVERNANCE_GROUP',
		    Identity: 'IDENTITY'
		};
		exports.FullcampaignAllOfSourcesWithOrphanEntitlementsBetaTypeEnum = {
		    Source: 'SOURCE'
		};
		exports.FullcampaignBetaTypeEnum = {
		    Manager: 'MANAGER',
		    SourceOwner: 'SOURCE_OWNER',
		    Search: 'SEARCH',
		    RoleComposition: 'ROLE_COMPOSITION'
		};
		exports.FullcampaignBetaStatusEnum = {
		    Pending: 'PENDING',
		    Staged: 'STAGED',
		    Canceling: 'CANCELING',
		    Activating: 'ACTIVATING',
		    Active: 'ACTIVE',
		    Completing: 'COMPLETING',
		    Completed: 'COMPLETED',
		    Error: 'ERROR',
		    Archived: 'ARCHIVED'
		};
		exports.FullcampaignBetaCorrelatedStatusEnum = {
		    Correlated: 'CORRELATED',
		    Uncorrelated: 'UNCORRELATED'
		};
		exports.FullcampaignBetaMandatoryCommentRequirementEnum = {
		    AllDecisions: 'ALL_DECISIONS',
		    RevokeOnlyDecisions: 'REVOKE_ONLY_DECISIONS',
		    NoDecisions: 'NO_DECISIONS'
		};
		/**
		 * OAuth2 Grant Type
		 * @export
		 * @enum {string}
		 */
		exports.GrantTypeBeta = {
		    ClientCredentials: 'CLIENT_CREDENTIALS',
		    AuthorizationCode: 'AUTHORIZATION_CODE',
		    RefreshToken: 'REFRESH_TOKEN'
		};
		/**
		 * Defines the HTTP Authentication type. Additional values may be added in the future.  If *NO_AUTH* is selected, no extra information will be in HttpConfig.  If *BASIC_AUTH* is selected, HttpConfig will include BasicAuthConfig with Username and Password as strings.  If *BEARER_TOKEN* is selected, HttpConfig will include BearerTokenAuthConfig with Token as string.
		 * @export
		 * @enum {string}
		 */
		exports.HttpAuthenticationTypeBeta = {
		    NoAuth: 'NO_AUTH',
		    BasicAuth: 'BASIC_AUTH',
		    BearerToken: 'BEARER_TOKEN'
		};
		/**
		 * HTTP response modes, i.e. SYNC, ASYNC, or DYNAMIC.
		 * @export
		 * @enum {string}
		 */
		exports.HttpDispatchModeBeta = {
		    Sync: 'SYNC',
		    Async: 'ASYNC',
		    Dynamic: 'DYNAMIC'
		};
		exports.IdentityAttributesChangedIdentityBetaTypeEnum = {
		    Identity: 'IDENTITY'
		};
		exports.IdentityBetaProcessingStateEnum = {
		    Error: 'ERROR',
		    Ok: 'OK',
		    Null: 'null'
		};
		exports.IdentityBetaIdentityStatusEnum = {
		    Unregistered: 'UNREGISTERED',
		    Registered: 'REGISTERED',
		    Pending: 'PENDING',
		    Warning: 'WARNING',
		    Disabled: 'DISABLED',
		    Active: 'ACTIVE',
		    Deactivated: 'DEACTIVATED',
		    Terminated: 'TERMINATED',
		    Error: 'ERROR',
		    Locked: 'LOCKED'
		};
		exports.IdentityCertificationTaskBetaTypeEnum = {
		    Reassign: 'REASSIGN'
		};
		exports.IdentityCertificationTaskBetaStatusEnum = {
		    Queued: 'QUEUED',
		    InProgress: 'IN_PROGRESS',
		    Success: 'SUCCESS',
		    Error: 'ERROR'
		};
		exports.IdentityCreatedIdentityBetaTypeEnum = {
		    Identity: 'IDENTITY'
		};
		exports.IdentityDeletedIdentityBetaTypeEnum = {
		    Identity: 'IDENTITY'
		};
		exports.IdentityDtoBetaProcessingStateEnum = {
		    Error: 'ERROR',
		    Ok: 'OK',
		    Null: 'null'
		};
		exports.IdentityDtoBetaIdentityStatusEnum = {
		    Unregistered: 'UNREGISTERED',
		    Registered: 'REGISTERED',
		    Pending: 'PENDING',
		    Warning: 'WARNING',
		    Disabled: 'DISABLED',
		    Active: 'ACTIVE',
		    Deactivated: 'DEACTIVATED',
		    Terminated: 'TERMINATED',
		    Error: 'ERROR',
		    Locked: 'LOCKED'
		};
		exports.IdentityDtoManagerRefBetaTypeEnum = {
		    Identity: 'IDENTITY'
		};
		exports.IdentityPreviewResponseIdentityBetaTypeEnum = {
		    Identity: 'IDENTITY'
		};
		exports.IdentityProfile1AllOfAuthoritativeSourceBetaTypeEnum = {
		    Source: 'SOURCE'
		};
		exports.IdentityProfileAllOfAuthoritativeSourceBetaTypeEnum = {
		    Source: 'SOURCE'
		};
		exports.IdentityProfileAllOfOwnerBetaTypeEnum = {
		    Identity: 'IDENTITY'
		};
		exports.IdentitySyncJobBetaStatusEnum = {
		    Queued: 'QUEUED',
		    InProgress: 'IN_PROGRESS',
		    Success: 'SUCCESS',
		    Error: 'ERROR'
		};
		exports.IdentityWithNewAccessAccessRefsInnerBetaTypeEnum = {
		    Entitlement: 'ENTITLEMENT'
		};
		exports.ImportObjectBetaTypeEnum = {
		    IdentityObjectConfig: 'IDENTITY_OBJECT_CONFIG',
		    IdentityProfile: 'IDENTITY_PROFILE',
		    Rule: 'RULE',
		    Source: 'SOURCE',
		    Transform: 'TRANSFORM',
		    TriggerSubscription: 'TRIGGER_SUBSCRIPTION'
		};
		exports.ImportOptionsBetaExcludeTypesEnum = {
		    IdentityObjectConfig: 'IDENTITY_OBJECT_CONFIG',
		    IdentityProfile: 'IDENTITY_PROFILE',
		    Rule: 'RULE',
		    Source: 'SOURCE',
		    Transform: 'TRANSFORM',
		    TriggerSubscription: 'TRIGGER_SUBSCRIPTION'
		};
		exports.ImportOptionsBetaIncludeTypesEnum = {
		    IdentityObjectConfig: 'IDENTITY_OBJECT_CONFIG',
		    IdentityProfile: 'IDENTITY_PROFILE',
		    Rule: 'RULE',
		    Source: 'SOURCE',
		    Transform: 'TRANSFORM',
		    TriggerSubscription: 'TRIGGER_SUBSCRIPTION'
		};
		exports.ImportOptionsBetaDefaultReferencesEnum = {
		    IdentityObjectConfig: 'IDENTITY_OBJECT_CONFIG',
		    IdentityProfile: 'IDENTITY_PROFILE',
		    Rule: 'RULE',
		    Source: 'SOURCE',
		    Transform: 'TRANSFORM',
		    TriggerSubscription: 'TRIGGER_SUBSCRIPTION'
		};
		/**
		 * Defines the Invocation type.  **TEST** The trigger was invocated as a test, either via the test subscription button in the UI or via the start test invocation API.  **REAL_TIME** The trigger subscription is live and was invocated by a real event in IdentityNow.
		 * @export
		 * @enum {string}
		 */
		exports.InvocationStatusTypeBeta = {
		    Test: 'TEST',
		    RealTime: 'REAL_TIME'
		};
		exports.JsonPatchOperationBetaOpEnum = {
		    Add: 'add',
		    Remove: 'remove',
		    Replace: 'replace',
		    Move: 'move',
		    Copy: 'copy',
		    Test: 'test'
		};
		exports.KbaAuthResponseBetaStatusEnum = {
		    Pending: 'PENDING',
		    Success: 'SUCCESS',
		    Failed: 'FAILED',
		    Lockout: 'LOCKOUT',
		    NotEnoughData: 'NOT_ENOUGH_DATA'
		};
		exports.LatestOutlierSummaryBetaTypeEnum = {
		    LowSimilarity: 'LOW_SIMILARITY',
		    Structural: 'STRUCTURAL'
		};
		exports.ListWorkgroupMembers200ResponseInnerBetaTypeEnum = {
		    Identity: 'IDENTITY'
		};
		/**
		 * An indicator of how the locale was selected. *DEFAULT* means the locale is the system default. *REQUEST* means the locale was selected from the request context (i.e., best match based on the *Accept-Language* header). Additional values may be added in the future without notice.
		 * @export
		 * @enum {string}
		 */
		exports.LocaleOriginBeta = {
		    Default: 'DEFAULT',
		    Request: 'REQUEST',
		    Null: 'null'
		};
		exports.MailFromAttributesBetaMailFromDomainStatusEnum = {
		    Pending: 'PENDING',
		    Success: 'SUCCESS',
		    Failed: 'FAILED'
		};
		/**
		 *
		 * @export
		 * @enum {string}
		 */
		exports.ManagedClientStatusEnumBeta = {
		    Normal: 'NORMAL',
		    Undefined: 'UNDEFINED',
		    NotConfigured: 'NOT_CONFIGURED',
		    Configuring: 'CONFIGURING',
		    Warning: 'WARNING',
		    Error: 'ERROR',
		    Failed: 'FAILED'
		};
		/**
		 * Managed Client type
		 * @export
		 * @enum {string}
		 */
		exports.ManagedClientTypeBeta = {
		    Ccg: 'CCG',
		    Va: 'VA',
		    Internal: 'INTERNAL',
		    IiqHarvester: 'IIQ_HARVESTER',
		    Null: 'null'
		};
		/**
		 * The Type of Cluster
		 * @export
		 * @enum {string}
		 */
		exports.ManagedClusterTypesBeta = {
		    Idn: 'idn',
		    Iai: 'iai'
		};
		exports.ManualWorkItemDetailsCurrentOwnerBetaTypeEnum = {
		    GovernanceGroup: 'GOVERNANCE_GROUP',
		    Identity: 'IDENTITY'
		};
		exports.ManualWorkItemDetailsOriginalOwnerBetaTypeEnum = {
		    GovernanceGroup: 'GOVERNANCE_GROUP',
		    Identity: 'IDENTITY'
		};
		/**
		 * Indicates the state of the request processing for this item: * PENDING: The request for this item is awaiting processing. * APPROVED: The request for this item has been approved. * REJECTED: The request for this item was rejected. * EXPIRED: The request for this item expired with no action taken. * CANCELLED: The request for this item was cancelled with no user action. * ARCHIVED: The request for this item has been archived after completion.
		 * @export
		 * @enum {string}
		 */
		exports.ManualWorkItemStateBeta = {
		    Pending: 'PENDING',
		    Approved: 'APPROVED',
		    Rejected: 'REJECTED',
		    Expired: 'EXPIRED',
		    Cancelled: 'CANCELLED',
		    Archived: 'ARCHIVED'
		};
		/**
		 *
		 * @export
		 * @enum {string}
		 */
		exports.MediumBeta = {
		    Email: 'EMAIL',
		    Sms: 'SMS',
		    Phone: 'PHONE',
		    Slack: 'SLACK',
		    Teams: 'TEAMS'
		};
		exports.MfaConfigTestResponseBetaStateEnum = {
		    Success: 'SUCCESS',
		    Failed: 'FAILED'
		};
		/**
		 * | Construct       | Date Time Pattern | Description | | ---------       | ----------------- | ----------- | | ISO8601         | `yyyy-MM-dd\'T\'HH:mm:ss.SSSX` | The ISO8601 standard. |           | LDAP            | `yyyyMMddHHmmss.Z`           | The LDAP standard.    | | PEOPLE_SOFT     | `MM/dd/yyyy`                 | The date format People Soft uses. | | EPOCH_TIME_JAVA | # ms from midnight, January 1st, 1970 | The incoming date value as elapsed time in milliseconds from midnight, January 1st, 1970. | | EPOCH_TIME_WIN32| # intervals of 100ns from midnight, January 1st, 1601 | The incoming date value as elapsed time in 100-nanosecond intervals from midnight, January 1st, 1601. |
		 * @export
		 * @enum {string}
		 */
		exports.NamedConstructsBeta = {
		    Iso8601: 'ISO8601',
		    Ldap: 'LDAP',
		    PeopleSoft: 'PEOPLE_SOFT',
		    EpochTimeJava: 'EPOCH_TIME_JAVA',
		    EpochTimeWin32: 'EPOCH_TIME_WIN32'
		};
		exports.NativeChangeDetectionConfigBetaOperationsEnum = {
		    Updated: 'ACCOUNT_UPDATED',
		    Created: 'ACCOUNT_CREATED',
		    Deleted: 'ACCOUNT_DELETED'
		};
		exports.NonEmployeeBulkUploadJobBetaStatusEnum = {
		    Pending: 'PENDING',
		    InProgress: 'IN_PROGRESS',
		    Completed: 'COMPLETED',
		    Error: 'ERROR'
		};
		exports.NonEmployeeBulkUploadStatusBetaStatusEnum = {
		    Pending: 'PENDING',
		    InProgress: 'IN_PROGRESS',
		    Completed: 'COMPLETED',
		    Error: 'ERROR'
		};
		/**
		 * Enum representing the type of data a schema attribute accepts.
		 * @export
		 * @enum {string}
		 */
		exports.NonEmployeeSchemaAttributeTypeBeta = {
		    Text: 'TEXT',
		    Date: 'DATE',
		    Identity: 'IDENTITY'
		};
		exports.OutlierBetaTypeEnum = {
		    LowSimilarity: 'LOW_SIMILARITY',
		    Structural: 'STRUCTURAL'
		};
		exports.OutlierBetaUnignoreTypeEnum = {
		    Manual: 'MANUAL',
		    Automatic: 'AUTOMATIC',
		    Null: 'null'
		};
		exports.OutlierContributingFeatureBetaValueTypeEnum = {
		    Integer: 'INTEGER',
		    Float: 'FLOAT'
		};
		exports.OutlierFeatureSummaryOutlierFeatureDisplayValuesInnerBetaValueTypeEnum = {
		    Integer: 'INTEGER',
		    Float: 'FLOAT'
		};
		exports.OutlierSummaryBetaTypeEnum = {
		    LowSimilarity: 'LOW_SIMILARITY',
		    Structural: 'STRUCTURAL'
		};
		exports.OutliersContributingFeatureAccessItemsBetaAccessTypeEnum = {
		    Entitlement: 'ENTITLEMENT',
		    AccessProfile: 'ACCESS_PROFILE',
		    Role: 'ROLE'
		};
		exports.OwnerDtoBetaTypeEnum = {
		    Identity: 'IDENTITY'
		};
		exports.OwnerReferenceBetaTypeEnum = {
		    Identity: 'IDENTITY'
		};
		exports.OwnerReferenceDtoBetaTypeEnum = {
		    Identity: 'IDENTITY'
		};
		exports.OwnerReferenceSegmentsBetaTypeEnum = {
		    Identity: 'IDENTITY'
		};
		exports.PasswordChangeResponseBetaStateEnum = {
		    InProgress: 'IN_PROGRESS',
		    Finished: 'FINISHED',
		    Failed: 'FAILED'
		};
		exports.PasswordStatusBetaStateEnum = {
		    InProgress: 'IN_PROGRESS',
		    Finished: 'FINISHED',
		    Failed: 'FAILED'
		};
		exports.PatOwnerBetaTypeEnum = {
		    Identity: 'IDENTITY'
		};
		exports.PatchPotentialRoleRequestInnerBetaOpEnum = {
		    Remove: 'remove',
		    Replace: 'replace'
		};
		/**
		 * Enum represents action that is being processed on an approval.
		 * @export
		 * @enum {string}
		 */
		exports.PendingApprovalActionBeta = {
		    Approved: 'APPROVED',
		    Rejected: 'REJECTED',
		    Forwarded: 'FORWARDED'
		};
		exports.PreApprovalTriggerDetailsBetaDecisionEnum = {
		    Approved: 'APPROVED',
		    Rejected: 'REJECTED'
		};
		exports.ProvisioningCompletedAccountRequestsInnerAttributeRequestsInnerBetaOperationEnum = {
		    Add: 'Add',
		    Set: 'Set',
		    Remove: 'Remove'
		};
		exports.ProvisioningCompletedAccountRequestsInnerBetaProvisioningResultEnum = {
		    Success: 'SUCCESS',
		    Pending: 'PENDING',
		    Failed: 'FAILED'
		};
		exports.ProvisioningCompletedAccountRequestsInnerSourceBetaTypeEnum = {
		    Source: 'SOURCE'
		};
		exports.ProvisioningCompletedRecipientBetaTypeEnum = {
		    Identity: 'IDENTITY'
		};
		exports.ProvisioningCompletedRequesterBetaTypeEnum = {
		    Identity: 'IDENTITY'
		};
		exports.ProvisioningConfigManagedResourceRefsInnerBetaTypeEnum = {
		    Source: 'SOURCE'
		};
		/**
		 * Supported operations on ProvisioningCriteria
		 * @export
		 * @enum {string}
		 */
		exports.ProvisioningCriteriaOperationBeta = {
		    Equals: 'EQUALS',
		    NotEquals: 'NOT_EQUALS',
		    Contains: 'CONTAINS',
		    Has: 'HAS',
		    And: 'AND',
		    Or: 'OR'
		};
		/**
		 * Provisioning state of an account activity item
		 * @export
		 * @enum {string}
		 */
		exports.ProvisioningStateBeta = {
		    Pending: 'PENDING',
		    Finished: 'FINISHED',
		    Unverifiable: 'UNVERIFIABLE',
		    Commited: 'COMMITED',
		    Failed: 'FAILED',
		    Retry: 'RETRY'
		};
		exports.ReassignReferenceBetaTypeEnum = {
		    TargetSummary: 'TARGET_SUMMARY',
		    Item: 'ITEM',
		    IdentitySummary: 'IDENTITY_SUMMARY'
		};
		/**
		 * The approval reassignment type.  * MANUAL_REASSIGNMENT: An approval with this reassignment type has been specifically reassigned by the approval task\'s owner, from their queue to someone else\'s.  * AUTOMATIC_REASSIGNMENT: An approval with this reassignment type has been automatically reassigned from another approver\'s queue, according to that approver\'s reassignment configuration. The approver\'s reassignment configuration may be set up to automatically reassign approval tasks for a defined (or possibly open-ended) period of time. * AUTO_ESCALATION: An approval with this reassignment type has been automatically reassigned from another approver\'s queue, according to the request\'s escalation configuration. For more information about escalation configuration, refer to [Setting Global Reminders and Escalation Policies](https://documentation.sailpoint.com/saas/help/requests/config_emails.html). * SELF_REVIEW_DELEGATION: An approval with this reassignment type has been automatically reassigned by the system to prevent self-review. This helps prevent situations like a requester being tasked with approving their own request. For more information about preventing self-review, refer to [Self-review Prevention](https://documentation.sailpoint.com/saas/help/users/work_reassignment.html#self-review-prevention) and [Preventing Self-approval](https://documentation.sailpoint.com/saas/help/requests/config_ap_roles.html#preventing-self-approval).
		 * @export
		 * @enum {string}
		 */
		exports.ReassignmentTypeBeta = {
		    ManualReassignment: 'MANUAL_REASSIGNMENT',
		    AutomaticReassignment: 'AUTOMATIC_REASSIGNMENT',
		    AutoEscalation: 'AUTO_ESCALATION',
		    SelfReviewDelegation: 'SELF_REVIEW_DELEGATION'
		};
		/**
		 * Enum list containing types of Reassignment that can be found in the evaluate response.
		 * @export
		 * @enum {string}
		 */
		exports.ReassignmentTypeEnumBeta = {
		    ManualReassignment: 'MANUAL_REASSIGNMENT,',
		    AutomaticReassignment: 'AUTOMATIC_REASSIGNMENT,',
		    AutoEscalation: 'AUTO_ESCALATION,',
		    SelfReviewDelegation: 'SELF_REVIEW_DELEGATION'
		};
		exports.RecommendationResponseBetaRecommendationEnum = {
		    True: 'true',
		    False: 'false',
		    Maybe: 'MAYBE',
		    NotFound: 'NOT_FOUND'
		};
		exports.ReportResultReferenceAllOfBetaStatusEnum = {
		    Success: 'SUCCESS',
		    Warning: 'WARNING',
		    Error: 'ERROR',
		    Terminated: 'TERMINATED',
		    TempError: 'TEMP_ERROR',
		    Pending: 'PENDING'
		};
		exports.ReportResultReferenceBetaTypeEnum = {
		    ReportResult: 'REPORT_RESULT'
		};
		exports.ReportResultReferenceBetaStatusEnum = {
		    Success: 'SUCCESS',
		    Warning: 'WARNING',
		    Error: 'ERROR',
		    Terminated: 'TERMINATED',
		    TempError: 'TEMP_ERROR',
		    Pending: 'PENDING'
		};
		/**
		 * type of a Report
		 * @export
		 * @enum {string}
		 */
		exports.ReportTypeBeta = {
		    CampaignCompositionReport: 'CAMPAIGN_COMPOSITION_REPORT',
		    CampaignRemediationStatusReport: 'CAMPAIGN_REMEDIATION_STATUS_REPORT',
		    CampaignStatusReport: 'CAMPAIGN_STATUS_REPORT',
		    CertificationSignoffReport: 'CERTIFICATION_SIGNOFF_REPORT'
		};
		exports.RequestableObjectReferenceBetaTypeEnum = {
		    AccessProfile: 'ACCESS_PROFILE',
		    Role: 'ROLE',
		    Entitlement: 'ENTITLEMENT'
		};
		/**
		 * Status indicating the ability of an access request for the object to be made by or on behalf of the identity specified by *identity-id*. *AVAILABLE* indicates the object is available to request. *PENDING* indicates the object is unavailable because the identity has a pending request in flight. *ASSIGNED* indicates the object is unavailable because the identity already has the indicated role or access profile. If *identity-id* is not specified (allowed only for admin users), then status will be *AVAILABLE* for all results.
		 * @export
		 * @enum {string}
		 */
		exports.RequestableObjectRequestStatusBeta = {
		    Available: 'AVAILABLE',
		    Pending: 'PENDING',
		    Assigned: 'ASSIGNED',
		    Null: 'null'
		};
		/**
		 * The currently supported requestable object types.
		 * @export
		 * @enum {string}
		 */
		exports.RequestableObjectTypeBeta = {
		    AccessProfile: 'ACCESS_PROFILE',
		    Role: 'ROLE',
		    Entitlement: 'ENTITLEMENT'
		};
		exports.RequestedItemStatusBetaTypeEnum = {
		    AccessProfile: 'ACCESS_PROFILE',
		    Role: 'ROLE',
		    Entitlement: 'ENTITLEMENT',
		    Null: 'null'
		};
		exports.RequestedItemStatusPreApprovalTriggerDetailsBetaDecisionEnum = {
		    Approved: 'APPROVED',
		    Rejected: 'REJECTED'
		};
		/**
		 * Indicates the state of an access request: * EXECUTING: The request is executing, which indicates the system is doing some processing. * REQUEST_COMPLETED: Indicates the request  has been completed. * CANCELLED: The request was cancelled with no user input. * TERMINATED: The request has been terminated before it was able to complete. * PROVISIONING_VERIFICATION_PENDING: The request has finished any approval steps and provisioning is waiting to be verified. * REJECTED: The request was rejected. * PROVISIONING_FAILED: The request has failed to complete. * NOT_ALL_ITEMS_PROVISIONED: One or more of the requested items failed to complete, but there were one or more  successes. * ERROR: An error occurred during request processing.
		 * @export
		 * @enum {string}
		 */
		exports.RequestedItemStatusRequestStateBeta = {
		    Executing: 'EXECUTING',
		    RequestCompleted: 'REQUEST_COMPLETED',
		    Cancelled: 'CANCELLED',
		    Terminated: 'TERMINATED',
		    ProvisioningVerificationPending: 'PROVISIONING_VERIFICATION_PENDING',
		    Rejected: 'REJECTED',
		    ProvisioningFailed: 'PROVISIONING_FAILED',
		    NotAllItemsProvisioned: 'NOT_ALL_ITEMS_PROVISIONED',
		    Error: 'ERROR'
		};
		exports.RequestedItemStatusSodViolationContextBetaStateEnum = {
		    Success: 'SUCCESS',
		    Error: 'ERROR',
		    Null: 'null'
		};
		exports.ReviewerBetaTypeEnum = {
		    Identity: 'IDENTITY',
		    GovernanceGroup: 'GOVERNANCE_GROUP'
		};
		/**
		 * Type which indicates how a particular Identity obtained a particular Role
		 * @export
		 * @enum {string}
		 */
		exports.RoleAssignmentSourceTypeBeta = {
		    AccessRequest: 'ACCESS_REQUEST',
		    RoleMembership: 'ROLE_MEMBERSHIP'
		};
		/**
		 * Indicates whether the associated criteria represents an expression on identity attributes, account attributes, or entitlements, respectively.
		 * @export
		 * @enum {string}
		 */
		exports.RoleCriteriaKeyTypeBeta = {
		    Identity: 'IDENTITY',
		    Account: 'ACCOUNT',
		    Entitlement: 'ENTITLEMENT'
		};
		/**
		 * An operation
		 * @export
		 * @enum {string}
		 */
		exports.RoleCriteriaOperationBeta = {
		    Equals: 'EQUALS',
		    NotEquals: 'NOT_EQUALS',
		    Contains: 'CONTAINS',
		    StartsWith: 'STARTS_WITH',
		    EndsWith: 'ENDS_WITH',
		    And: 'AND',
		    Or: 'OR'
		};
		exports.RoleInsightsResponseBetaStatusEnum = {
		    Created: 'CREATED',
		    InProgress: 'IN PROGRESS',
		    Completed: 'COMPLETED',
		    Failed: 'FAILED'
		};
		/**
		 * This enum characterizes the type of a Role\'s membership selector. Only the following two are fully supported:  STANDARD: Indicates that Role membership is defined in terms of a criteria expression  IDENTITY_LIST: Indicates that Role membership is conferred on the specific identities listed
		 * @export
		 * @enum {string}
		 */
		exports.RoleMembershipSelectorTypeBeta = {
		    Standard: 'STANDARD',
		    IdentityList: 'IDENTITY_LIST'
		};
		/**
		 *
		 * @export
		 * @enum {string}
		 */
		exports.RoleMiningPotentialRoleExportStateBeta = {
		    Queued: 'QUEUED',
		    InProgress: 'IN_PROGRESS',
		    Success: 'SUCCESS',
		    Error: 'ERROR'
		};
		/**
		 * Provision state
		 * @export
		 * @enum {string}
		 */
		exports.RoleMiningPotentialRoleProvisionStateBeta = {
		    Potential: 'POTENTIAL',
		    Pending: 'PENDING',
		    Complete: 'COMPLETE',
		    Failed: 'FAILED'
		};
		/**
		 * Role type
		 * @export
		 * @enum {string}
		 */
		exports.RoleMiningRoleTypeBeta = {
		    Specialized: 'SPECIALIZED',
		    Common: 'COMMON'
		};
		/**
		 * The scoping method used in the current role mining session.
		 * @export
		 * @enum {string}
		 */
		exports.RoleMiningSessionScopingMethodBeta = {
		    Manual: 'MANUAL',
		    AutoRm: 'AUTO_RM'
		};
		/**
		 * Role mining session status
		 * @export
		 * @enum {string}
		 */
		exports.RoleMiningSessionStateBeta = {
		    Created: 'CREATED',
		    Updated: 'UPDATED',
		    IdentitiesObtained: 'IDENTITIES_OBTAINED',
		    PruneThresholdObtained: 'PRUNE_THRESHOLD_OBTAINED',
		    PotentialRolesProcessing: 'POTENTIAL_ROLES_PROCESSING',
		    PotentialRolesCreated: 'POTENTIAL_ROLES_CREATED'
		};
		exports.ScheduleBetaTypeEnum = {
		    Weekly: 'WEEKLY',
		    Monthly: 'MONTHLY',
		    Annually: 'ANNUALLY',
		    Calendar: 'CALENDAR'
		};
		exports.ScheduleDaysBetaTypeEnum = {
		    List: 'LIST',
		    Range: 'RANGE'
		};
		exports.ScheduleHoursBetaTypeEnum = {
		    List: 'LIST',
		    Range: 'RANGE'
		};
		exports.ScheduleMonthsBetaTypeEnum = {
		    List: 'LIST',
		    Range: 'RANGE'
		};
		/**
		 * Enum representing the currently supported schedule types.  Additional values may be added in the future without notice.
		 * @export
		 * @enum {string}
		 */
		exports.ScheduleTypeBeta = {
		    Daily: 'DAILY',
		    Weekly: 'WEEKLY',
		    Monthly: 'MONTHLY',
		    Calendar: 'CALENDAR',
		    Annually: 'ANNUALLY'
		};
		/**
		 * Enum representing the currently supported selector types.  LIST - the *values* array contains one or more distinct values.  RANGE - the *values* array contains two values: the start and end of the range, inclusive.  Additional values may be added in the future without notice.
		 * @export
		 * @enum {string}
		 */
		exports.SelectorTypeBeta = {
		    List: 'LIST',
		    Range: 'RANGE'
		};
		exports.SelfImportExportDtoBetaTypeEnum = {
		    AccessProfile: 'ACCESS_PROFILE',
		    AccessRequestConfig: 'ACCESS_REQUEST_CONFIG',
		    AttrSyncSourceConfig: 'ATTR_SYNC_SOURCE_CONFIG',
		    AuthOrg: 'AUTH_ORG',
		    CampaignFilter: 'CAMPAIGN_FILTER',
		    FormDefinition: 'FORM_DEFINITION',
		    GovernanceGroup: 'GOVERNANCE_GROUP',
		    IdentityObjectConfig: 'IDENTITY_OBJECT_CONFIG',
		    IdentityProfile: 'IDENTITY_PROFILE',
		    LifecycleState: 'LIFECYCLE_STATE',
		    NotificationTemplate: 'NOTIFICATION_TEMPLATE',
		    PasswordPolicy: 'PASSWORD_POLICY',
		    PasswordSyncGroup: 'PASSWORD_SYNC_GROUP',
		    PublicIdentitiesConfig: 'PUBLIC_IDENTITIES_CONFIG',
		    Role: 'ROLE',
		    Rule: 'RULE',
		    Segment: 'SEGMENT',
		    ServiceDeskIntegration: 'SERVICE_DESK_INTEGRATION',
		    SodPolicy: 'SOD_POLICY',
		    Source: 'SOURCE',
		    Tag: 'TAG',
		    Transform: 'TRANSFORM',
		    TriggerSubscription: 'TRIGGER_SUBSCRIPTION',
		    Workflow: 'WORKFLOW'
		};
		exports.SendTestNotificationRequestDtoBetaMediumEnum = {
		    Email: 'EMAIL',
		    Slack: 'SLACK',
		    Teams: 'TEAMS'
		};
		exports.SendTokenRequestBetaDeliveryTypeEnum = {
		    SmsPersonal: 'SMS_PERSONAL',
		    VoicePersonal: 'VOICE_PERSONAL',
		    SmsWork: 'SMS_WORK',
		    VoiceWork: 'VOICE_WORK',
		    EmailWork: 'EMAIL_WORK',
		    EmailPersonal: 'EMAIL_PERSONAL'
		};
		exports.SendTokenResponseBetaStatusEnum = {
		    Success: 'SUCCESS',
		    Failed: 'FAILED'
		};
		exports.ServiceDeskSourceBetaTypeEnum = {
		    Source: 'SOURCE'
		};
		exports.SlimcampaignBetaTypeEnum = {
		    Manager: 'MANAGER',
		    SourceOwner: 'SOURCE_OWNER',
		    Search: 'SEARCH',
		    RoleComposition: 'ROLE_COMPOSITION'
		};
		exports.SlimcampaignBetaStatusEnum = {
		    Pending: 'PENDING',
		    Staged: 'STAGED',
		    Canceling: 'CANCELING',
		    Activating: 'ACTIVATING',
		    Active: 'ACTIVE',
		    Completing: 'COMPLETING',
		    Completed: 'COMPLETED',
		    Error: 'ERROR',
		    Archived: 'ARCHIVED'
		};
		exports.SlimcampaignBetaCorrelatedStatusEnum = {
		    Correlated: 'CORRELATED',
		    Uncorrelated: 'UNCORRELATED'
		};
		exports.SodPolicyBetaStateEnum = {
		    Enforced: 'ENFORCED',
		    NotEnforced: 'NOT_ENFORCED'
		};
		exports.SodPolicyBetaTypeEnum = {
		    General: 'GENERAL',
		    ConflictingAccessBased: 'CONFLICTING_ACCESS_BASED'
		};
		exports.SodPolicyDtoBetaTypeEnum = {
		    SodPolicy: 'SOD_POLICY'
		};
		exports.SodRecipientBetaTypeEnum = {
		    Identity: 'IDENTITY'
		};
		exports.SodReportResultDtoBetaTypeEnum = {
		    ReportResult: 'REPORT_RESULT'
		};
		exports.SodViolationContextCheckCompleted1BetaStateEnum = {
		    Success: 'SUCCESS',
		    Error: 'ERROR'
		};
		exports.SodViolationContextCheckCompletedBetaStateEnum = {
		    Success: 'SUCCESS',
		    Error: 'ERROR',
		    Null: 'null'
		};
		exports.SourceAccountCorrelationConfigBetaTypeEnum = {
		    AccountCorrelationConfig: 'ACCOUNT_CORRELATION_CONFIG'
		};
		exports.SourceAccountCorrelationRuleBetaTypeEnum = {
		    Rule: 'RULE'
		};
		exports.SourceBeforeProvisioningRuleBetaTypeEnum = {
		    Rule: 'RULE'
		};
		exports.SourceClusterBetaTypeEnum = {
		    Cluster: 'CLUSTER'
		};
		exports.SourceClusterDtoBetaTypeEnum = {
		    Cluster: 'CLUSTER'
		};
		exports.SourceCreatedActorBetaTypeEnum = {
		    Identity: 'IDENTITY'
		};
		exports.SourceDeletedActorBetaTypeEnum = {
		    Identity: 'IDENTITY'
		};
		/**
		 * Optional features that can be supported by an source. * AUTHENTICATE: The source supports pass-through authentication. * COMPOSITE: The source supports composite source creation. * DIRECT_PERMISSIONS: The source supports returning DirectPermissions. * DISCOVER_SCHEMA: The source supports discovering schemas for users and groups. * ENABLE The source supports reading if an account is enabled or disabled. * MANAGER_LOOKUP: The source supports looking up managers as they are encountered in a feed. This is the opposite of NO_RANDOM_ACCESS. * NO_RANDOM_ACCESS: The source does not support random access and the getObject() methods should not be called and expected to perform. * PROXY: The source can serve as a proxy for another source. When an source has a proxy, all connector calls made with that source are redirected through the connector for the proxy source. * SEARCH * TEMPLATE * UNLOCK: The source supports reading if an account is locked or unlocked. * UNSTRUCTURED_TARGETS: The source supports returning unstructured Targets. * SHAREPOINT_TARGET: The source supports returning unstructured Target data for SharePoint. It will be typically used by AD, LDAP sources. * PROVISIONING: The source can both read and write accounts. Having this feature implies that the provision() method is implemented. It also means that direct and target permissions can also be provisioned if they can be returned by aggregation. * GROUP_PROVISIONING: The source can both read and write groups. Having this feature implies that the provision() method is implemented. * SYNC_PROVISIONING: The source can provision accounts synchronously. * PASSWORD: The source can provision password changes. Since sources can never read passwords, this is should only be used in conjunction with the PROVISIONING feature. * CURRENT_PASSWORD: Some source types support verification of the current password * ACCOUNT_ONLY_REQUEST: The source supports requesting accounts without entitlements. * ADDITIONAL_ACCOUNT_REQUEST: The source supports requesting additional accounts. * NO_AGGREGATION: A source that does not support aggregation. * GROUPS_HAVE_MEMBERS: The source models group memberships with a member attribute on the group object rather than a groups attribute on the account object. This effects the implementation of delta account aggregation. * NO_PERMISSIONS_PROVISIONING: Indicates that the connector cannot provision direct or target permissions for accounts. When DIRECT_PERMISSIONS and PROVISIONING features are present, it is assumed that the connector can also provision direct permissions. This feature disables that assumption and causes permission request to be converted to work items for accounts. * NO_GROUP_PERMISSIONS_PROVISIONING: Indicates that the connector cannot provision direct or target permissions for groups. When DIRECT_PERMISSIONS and PROVISIONING features are present, it is assumed that the connector can also provision direct permissions. This feature disables that assumption and causes permission request to be converted to work items for groups. * NO_UNSTRUCTURED_TARGETS_PROVISIONING: This string will be replaced by NO_GROUP_PERMISSIONS_PROVISIONING and NO_PERMISSIONS_PROVISIONING. * NO_DIRECT_PERMISSIONS_PROVISIONING: This string will be replaced by NO_GROUP_PERMISSIONS_PROVISIONING and NO_PERMISSIONS_PROVISIONING.
		 * @export
		 * @enum {string}
		 */
		exports.SourceFeatureBeta = {
		    Authenticate: 'AUTHENTICATE',
		    Composite: 'COMPOSITE',
		    DirectPermissions: 'DIRECT_PERMISSIONS',
		    DiscoverSchema: 'DISCOVER_SCHEMA',
		    Enable: 'ENABLE',
		    ManagerLookup: 'MANAGER_LOOKUP',
		    NoRandomAccess: 'NO_RANDOM_ACCESS',
		    Proxy: 'PROXY',
		    Search: 'SEARCH',
		    Template: 'TEMPLATE',
		    Unlock: 'UNLOCK',
		    UnstructuredTargets: 'UNSTRUCTURED_TARGETS',
		    SharepointTarget: 'SHAREPOINT_TARGET',
		    Provisioning: 'PROVISIONING',
		    GroupProvisioning: 'GROUP_PROVISIONING',
		    SyncProvisioning: 'SYNC_PROVISIONING',
		    Password: 'PASSWORD',
		    CurrentPassword: 'CURRENT_PASSWORD',
		    AccountOnlyRequest: 'ACCOUNT_ONLY_REQUEST',
		    AdditionalAccountRequest: 'ADDITIONAL_ACCOUNT_REQUEST',
		    NoAggregation: 'NO_AGGREGATION',
		    GroupsHaveMembers: 'GROUPS_HAVE_MEMBERS',
		    NoPermissionsProvisioning: 'NO_PERMISSIONS_PROVISIONING',
		    NoGroupPermissionsProvisioning: 'NO_GROUP_PERMISSIONS_PROVISIONING',
		    NoUnstructuredTargetsProvisioning: 'NO_UNSTRUCTURED_TARGETS_PROVISIONING',
		    NoDirectPermissionsProvisioning: 'NO_DIRECT_PERMISSIONS_PROVISIONING',
		    PreferUuid: 'PREFER_UUID'
		};
		exports.SourceManagementWorkgroupBetaTypeEnum = {
		    GovernanceGroup: 'GOVERNANCE_GROUP'
		};
		exports.SourceManagerCorrelationRuleBetaTypeEnum = {
		    Rule: 'RULE'
		};
		exports.SourceOwnerBetaTypeEnum = {
		    Identity: 'IDENTITY'
		};
		exports.SourcePasswordPoliciesInnerBetaTypeEnum = {
		    PasswordPolicy: 'PASSWORD_POLICY'
		};
		exports.SourceSchemasInnerBetaTypeEnum = {
		    ConnectorSchema: 'CONNECTOR_SCHEMA'
		};
		exports.SourceSyncJobBetaStatusEnum = {
		    Queued: 'QUEUED',
		    InProgress: 'IN_PROGRESS',
		    Success: 'SUCCESS',
		    Error: 'ERROR'
		};
		exports.SourceUpdatedActorBetaTypeEnum = {
		    Identity: 'IDENTITY'
		};
		exports.SourceUsageStatusBetaStatusEnum = {
		    Complete: 'COMPLETE',
		    Incomplete: 'INCOMPLETE'
		};
		exports.SpConfigExportJobBetaStatusEnum = {
		    NotStarted: 'NOT_STARTED',
		    InProgress: 'IN_PROGRESS',
		    Complete: 'COMPLETE',
		    Cancelled: 'CANCELLED',
		    Failed: 'FAILED'
		};
		exports.SpConfigExportJobBetaTypeEnum = {
		    Export: 'EXPORT',
		    Import: 'IMPORT'
		};
		exports.SpConfigExportJobStatusBetaStatusEnum = {
		    NotStarted: 'NOT_STARTED',
		    InProgress: 'IN_PROGRESS',
		    Complete: 'COMPLETE',
		    Cancelled: 'CANCELLED',
		    Failed: 'FAILED'
		};
		exports.SpConfigExportJobStatusBetaTypeEnum = {
		    Export: 'EXPORT',
		    Import: 'IMPORT'
		};
		exports.SpConfigImportJobStatusBetaStatusEnum = {
		    NotStarted: 'NOT_STARTED',
		    InProgress: 'IN_PROGRESS',
		    Complete: 'COMPLETE',
		    Cancelled: 'CANCELLED',
		    Failed: 'FAILED'
		};
		exports.SpConfigImportJobStatusBetaTypeEnum = {
		    Export: 'EXPORT',
		    Import: 'IMPORT'
		};
		exports.SpConfigJobBetaStatusEnum = {
		    NotStarted: 'NOT_STARTED',
		    InProgress: 'IN_PROGRESS',
		    Complete: 'COMPLETE',
		    Cancelled: 'CANCELLED',
		    Failed: 'FAILED'
		};
		exports.SpConfigJobBetaTypeEnum = {
		    Export: 'EXPORT',
		    Import: 'IMPORT'
		};
		/**
		 * Standard Log4j log level
		 * @export
		 * @enum {string}
		 */
		exports.StandardLevelBeta = {
		    False: 'false',
		    Fatal: 'FATAL',
		    Error: 'ERROR',
		    Warn: 'WARN',
		    Info: 'INFO',
		    Debug: 'DEBUG',
		    Trace: 'TRACE'
		};
		exports.StatusResponseBetaStatusEnum = {
		    Success: 'SUCCESS',
		    Failure: 'FAILURE'
		};
		exports.SubscriptionPatchRequestInnerBetaOpEnum = {
		    Add: 'add',
		    Remove: 'remove',
		    Replace: 'replace',
		    Move: 'move',
		    Copy: 'copy'
		};
		/**
		 * Subscription type. **NOTE** If type is EVENTBRIDGE, then eventBridgeConfig is required. If type is HTTP, then httpConfig is required.
		 * @export
		 * @enum {string}
		 */
		exports.SubscriptionTypeBeta = {
		    Http: 'HTTP',
		    Eventbridge: 'EVENTBRIDGE',
		    Inline: 'INLINE',
		    Script: 'SCRIPT',
		    Workflow: 'WORKFLOW'
		};
		exports.TaggedObjectDtoBetaTypeEnum = {
		    AccessProfile: 'ACCESS_PROFILE',
		    Application: 'APPLICATION',
		    Campaign: 'CAMPAIGN',
		    Entitlement: 'ENTITLEMENT',
		    Identity: 'IDENTITY',
		    Role: 'ROLE',
		    SodPolicy: 'SOD_POLICY',
		    Source: 'SOURCE'
		};
		exports.TaggedObjectObjectRefBetaTypeEnum = {
		    AccessProfile: 'ACCESS_PROFILE',
		    Application: 'APPLICATION',
		    Campaign: 'CAMPAIGN',
		    Entitlement: 'ENTITLEMENT',
		    Identity: 'IDENTITY',
		    Role: 'ROLE',
		    SodPolicy: 'SOD_POLICY',
		    Source: 'SOURCE'
		};
		exports.TaskResultDtoBetaTypeEnum = {
		    TaskResult: 'TASK_RESULT'
		};
		exports.TaskResultSimplifiedBetaCompletionStatusEnum = {
		    Success: 'Success',
		    Warning: 'Warning',
		    Error: 'Error',
		    Terminated: 'Terminated',
		    TempError: 'TempError'
		};
		exports.TaskStatusBetaTypeEnum = {
		    Quartz: 'QUARTZ',
		    Qpoc: 'QPOC',
		    QueuedTask: 'QUEUED_TASK'
		};
		exports.TaskStatusBetaCompletionStatusEnum = {
		    Success: 'Success',
		    Warning: 'Warning',
		    Error: 'Error',
		    Terminated: 'Terminated',
		    TempError: 'TempError'
		};
		exports.TaskStatusMessageBetaTypeEnum = {
		    Info: 'INFO',
		    Warn: 'WARN',
		    Error: 'ERROR'
		};
		exports.TemplateBulkDeleteDtoBetaMediumEnum = {
		    Email: 'EMAIL',
		    Phone: 'PHONE',
		    Sms: 'SMS'
		};
		exports.TemplateDtoBetaMediumEnum = {
		    Email: 'EMAIL',
		    Phone: 'PHONE',
		    Sms: 'SMS',
		    Slack: 'SLACK',
		    Teams: 'TEAMS'
		};
		exports.TemplateDtoDefaultBetaMediumEnum = {
		    Email: 'EMAIL',
		    Phone: 'PHONE',
		    Sms: 'SMS',
		    Slack: 'SLACK',
		    Teams: 'TEAMS'
		};
		exports.TokenAuthRequestBetaDeliveryTypeEnum = {
		    SmsPersonal: 'SMS_PERSONAL',
		    VoicePersonal: 'VOICE_PERSONAL',
		    SmsWork: 'SMS_WORK',
		    VoiceWork: 'VOICE_WORK',
		    EmailWork: 'EMAIL_WORK',
		    EmailPersonal: 'EMAIL_PERSONAL'
		};
		exports.TokenAuthResponseBetaStatusEnum = {
		    Pending: 'PENDING',
		    Success: 'SUCCESS',
		    Failed: 'FAILED',
		    Lockout: 'LOCKOUT',
		    NotEnoughData: 'NOT_ENOUGH_DATA'
		};
		exports.TransformBetaTypeEnum = {
		    AccountAttribute: 'accountAttribute',
		    Base64Decode: 'base64Decode',
		    Base64Encode: 'base64Encode',
		    Concat: 'concat',
		    Conditional: 'conditional',
		    DateCompare: 'dateCompare',
		    DateFormat: 'dateFormat',
		    DateMath: 'dateMath',
		    DecomposeDiacriticalMarks: 'decomposeDiacriticalMarks',
		    E164phone: 'e164phone',
		    FirstValid: 'firstValid',
		    Rule: 'rule',
		    IdentityAttribute: 'identityAttribute',
		    IndexOf: 'indexOf',
		    Iso3166: 'iso3166',
		    LastIndexOf: 'lastIndexOf',
		    LeftPad: 'leftPad',
		    Lookup: 'lookup',
		    Lower: 'lower',
		    NormalizeNames: 'normalizeNames',
		    RandomAlphaNumeric: 'randomAlphaNumeric',
		    RandomNumeric: 'randomNumeric',
		    Reference: 'reference',
		    ReplaceAll: 'replaceAll',
		    Replace: 'replace',
		    RightPad: 'rightPad',
		    Split: 'split',
		    Static: 'static',
		    Substring: 'substring',
		    Trim: 'trim',
		    Upper: 'upper',
		    UsernameGenerator: 'usernameGenerator',
		    Uuid: 'uuid'
		};
		exports.TransformReadBetaTypeEnum = {
		    AccountAttribute: 'accountAttribute',
		    Base64Decode: 'base64Decode',
		    Base64Encode: 'base64Encode',
		    Concat: 'concat',
		    Conditional: 'conditional',
		    DateCompare: 'dateCompare',
		    DateFormat: 'dateFormat',
		    DateMath: 'dateMath',
		    DecomposeDiacriticalMarks: 'decomposeDiacriticalMarks',
		    E164phone: 'e164phone',
		    FirstValid: 'firstValid',
		    Rule: 'rule',
		    IdentityAttribute: 'identityAttribute',
		    IndexOf: 'indexOf',
		    Iso3166: 'iso3166',
		    LastIndexOf: 'lastIndexOf',
		    LeftPad: 'leftPad',
		    Lookup: 'lookup',
		    Lower: 'lower',
		    NormalizeNames: 'normalizeNames',
		    RandomAlphaNumeric: 'randomAlphaNumeric',
		    RandomNumeric: 'randomNumeric',
		    Reference: 'reference',
		    ReplaceAll: 'replaceAll',
		    Replace: 'replace',
		    RightPad: 'rightPad',
		    Split: 'split',
		    Static: 'static',
		    Substring: 'substring',
		    Trim: 'trim',
		    Upper: 'upper',
		    UsernameGenerator: 'usernameGenerator',
		    Uuid: 'uuid'
		};
		/**
		 * The type of trigger.
		 * @export
		 * @enum {string}
		 */
		exports.TriggerTypeBeta = {
		    RequestResponse: 'REQUEST_RESPONSE',
		    FireAndForget: 'FIRE_AND_FORGET'
		};
		/**
		 * The type of provisioning policy usage.  In IdentityNow, a source can support various provisioning operations. For example, when a joiner is added to a source, this may trigger both CREATE and UPDATE provisioning operations.  Each usage type is considered a provisioning policy.  A source can have any number of these provisioning policies defined.  These are the common usage types:  CREATE - This usage type relates to \'Create Account Profile\', the provisioning template for the account to be created. For example, this would be used for a joiner on a source.   UPDATE - This usage type relates to \'Update Account Profile\', the provisioning template for the \'Update\' connector operations. For example, this would be used for an attribute sync on a source. ENABLE - This usage type relates to \'Enable Account Profile\', the provisioning template for the account to be enabled. For example, this could be used for a joiner on a source once the joiner\'s account is created.  DISABLE - This usage type relates to \'Disable Account Profile\', the provisioning template for the account to be disabled. For example, this could be used when a leaver is removed temporarily from a source.  You can use these four usage types for all your provisioning policy needs.
		 * @export
		 * @enum {string}
		 */
		exports.UsageTypeBeta = {
		    Create: 'CREATE',
		    Update: 'UPDATE',
		    Enable: 'ENABLE',
		    Disable: 'DISABLE',
		    Delete: 'DELETE',
		    Assign: 'ASSIGN',
		    Unassign: 'UNASSIGN',
		    CreateGroup: 'CREATE_GROUP',
		    UpdateGroup: 'UPDATE_GROUP',
		    DeleteGroup: 'DELETE_GROUP',
		    Register: 'REGISTER',
		    CreateIdentity: 'CREATE_IDENTITY',
		    UpdateIdentity: 'UPDATE_IDENTITY',
		    EditGroup: 'EDIT_GROUP',
		    Unlock: 'UNLOCK',
		    ChangePassword: 'CHANGE_PASSWORD'
		};
		exports.VAClusterStatusChangeEventBetaTypeEnum = {
		    Source: 'SOURCE',
		    Cluster: 'CLUSTER'
		};
		exports.VAClusterStatusChangeEventHealthCheckResultBetaStatusEnum = {
		    Succeeded: 'Succeeded',
		    Failed: 'Failed'
		};
		exports.VAClusterStatusChangeEventPreviousHealthCheckResultBetaStatusEnum = {
		    Succeeded: 'Succeeded',
		    Failed: 'Failed'
		};
		exports.VerificationResponseBetaStatusEnum = {
		    Pending: 'PENDING',
		    Success: 'SUCCESS',
		    Failed: 'FAILED',
		    Lockout: 'LOCKOUT',
		    NotEnoughData: 'NOT_ENOUGH_DATA'
		};
		exports.ViolationContextPolicyBetaTypeEnum = {
		    Entitlement: 'ENTITLEMENT'
		};
		exports.ViolationOwnerAssignmentConfigBetaAssignmentRuleEnum = {
		    Manager: 'MANAGER',
		    Static: 'STATIC',
		    Null: 'null'
		};
		exports.ViolationOwnerAssignmentConfigOwnerRefBetaTypeEnum = {
		    Identity: 'IDENTITY'
		};
		/**
		 * The state of a work item
		 * @export
		 * @enum {string}
		 */
		exports.WorkItemStateBeta = {
		    Finished: 'FINISHED',
		    Rejected: 'REJECTED',
		    Returned: 'RETURNED',
		    Expired: 'EXPIRED',
		    Pending: 'PENDING',
		    Canceled: 'CANCELED',
		    Null: 'null'
		};
		/**
		 * The type of the work item
		 * @export
		 * @enum {string}
		 */
		exports.WorkItemTypeBeta = {
		    Unknown: 'UNKNOWN',
		    Generic: 'GENERIC',
		    Certification: 'CERTIFICATION',
		    Remediation: 'REMEDIATION',
		    Delegation: 'DELEGATION',
		    Approval: 'APPROVAL',
		    Violationreview: 'VIOLATIONREVIEW',
		    Form: 'FORM',
		    Policyviolation: 'POLICYVIOLATION',
		    Challenge: 'CHALLENGE',
		    Impactanalysis: 'IMPACTANALYSIS',
		    Signoff: 'SIGNOFF',
		    Event: 'EVENT',
		    Manualaction: 'MANUALACTION',
		    Test: 'TEST'
		};
		exports.WorkflowAllOfCreatorBetaTypeEnum = {
		    Identity: 'IDENTITY'
		};
		exports.WorkflowBodyOwnerBetaTypeEnum = {
		    Identity: 'IDENTITY'
		};
		exports.WorkflowExecutionBetaStatusEnum = {
		    Completed: 'Completed',
		    Failed: 'Failed',
		    Canceled: 'Canceled',
		    Running: 'Running'
		};
		exports.WorkflowExecutionEventBetaTypeEnum = {
		    WorkflowExecutionScheduled: 'WorkflowExecutionScheduled',
		    WorkflowExecutionStarted: 'WorkflowExecutionStarted',
		    WorkflowExecutionCompleted: 'WorkflowExecutionCompleted',
		    WorkflowExecutionFailed: 'WorkflowExecutionFailed',
		    WorkflowTaskScheduled: 'WorkflowTaskScheduled',
		    WorkflowTaskStarted: 'WorkflowTaskStarted',
		    WorkflowTaskCompleted: 'WorkflowTaskCompleted',
		    WorkflowTaskFailed: 'WorkflowTaskFailed',
		    ActivityTaskScheduled: 'ActivityTaskScheduled',
		    ActivityTaskStarted: 'ActivityTaskStarted',
		    ActivityTaskCompleted: 'ActivityTaskCompleted',
		    ActivityTaskFailed: 'ActivityTaskFailed'
		};
		exports.WorkflowLibraryFormFieldsBetaTypeEnum = {
		    Text: 'text',
		    Textarea: 'textarea',
		    Boolean: 'boolean',
		    Email: 'email',
		    Url: 'url',
		    Number: 'number',
		    Json: 'json',
		    Checkbox: 'checkbox',
		    Jsonpath: 'jsonpath',
		    Select: 'select',
		    MultiType: 'multiType',
		    Duration: 'duration',
		    Toggle: 'toggle',
		    IdentityPicker: 'identityPicker',
		    GovernanceGroupPicker: 'governanceGroupPicker',
		    String: 'string',
		    Object: 'object',
		    Array: 'array',
		    Secret: 'secret',
		    KeyValuePairs: 'keyValuePairs',
		    EmailPicker: 'emailPicker',
		    AdvancedToggle: 'advancedToggle'
		};
		exports.WorkflowLibraryTriggerBetaTypeEnum = {
		    Event: 'EVENT',
		    Scheduled: 'SCHEDULED',
		    External: 'EXTERNAL'
		};
		exports.WorkflowTriggerBetaTypeEnum = {
		    Event: 'EVENT',
		    External: 'EXTERNAL',
		    Scheduled: 'SCHEDULED'
		};
		exports.WorkgroupConnectionDtoBetaConnectionTypeEnum = {
		    AccessRequestReviewer: 'AccessRequestReviewer',
		    Owner: 'Owner',
		    ManagementWorkgroup: 'ManagementWorkgroup'
		};
		/**
		 * AccessProfilesBetaApi - axios parameter creator
		 * @export
		 */
		var AccessProfilesBetaApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * This API creates an Access Profile. A token with API, ORG_ADMIN, ROLE_ADMIN, ROLE_SUBADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API. In addition, a token with only ROLE_SUBADMIN or SOURCE_SUBADMIN authority must be associated with the Access Profile\'s Source. The maximum supported length for the description field is 2000 characters. Longer descriptions will be preserved for existing access profiles, however, any new access profiles as well as any updates to existing descriptions will be limited to 2000 characters.
		         * @summary Create an Access Profile
		         * @param {AccessProfileBeta} accessProfileBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createAccessProfile: function (accessProfileBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'accessProfileBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('createAccessProfile', 'accessProfileBeta', accessProfileBeta);
		                            localVarPath = "/access-profiles";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(accessProfileBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API deletes an existing Access Profile.  The Access Profile must not be in use, for example, Access Profile can not be deleted if they belong to an Application, Life Cycle State or a Role. If it is, a 400 error is returned.  A token with API, ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to invoke this API. In addition, a SOURCE_SUBADMIN token must be able to administer the Source associated with the Access Profile.
		         * @summary Delete the specified Access Profile
		         * @param {string} id ID of the Access Profile to delete
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteAccessProfile: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('deleteAccessProfile', 'id', id);
		                            localVarPath = "/access-profiles/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'DELETE' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API initiates a bulk deletion of one or more Access Profiles.  By default, if any of the indicated Access Profiles are in use, no deletions will be performed and the **inUse** field of the response indicates the usages that must be removed first. If the request field **bestEffortOnly** is **true**, however, usages are reported in the **inUse** response field but all other indicated Access Profiles will be deleted.  A token with API, ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API. In addition, a SOURCE_SUBADMIN may only use this API to delete Access Profiles which are associated with Sources they are able to administer.
		         * @summary Delete Access Profile(s)
		         * @param {AccessProfileBulkDeleteRequestBeta} accessProfileBulkDeleteRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteAccessProfilesInBulk: function (accessProfileBulkDeleteRequestBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'accessProfileBulkDeleteRequestBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('deleteAccessProfilesInBulk', 'accessProfileBulkDeleteRequestBeta', accessProfileBulkDeleteRequestBeta);
		                            localVarPath = "/access-profiles/bulk-delete";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(accessProfileBulkDeleteRequestBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns an Access Profile by its ID.  A token with API, ORG_ADMIN, ROLE_ADMIN, ROLE_SUBADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		         * @summary Get an Access Profile
		         * @param {string} id ID of the Access Profile
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getAccessProfile: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getAccessProfile', 'id', id);
		                            localVarPath = "/access-profiles/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API lists the Entitlements associated with a given Access Profile  A token with API, ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to invoke this API. In addition, a token with SOURCE_SUBADMIN authority must have access to the Source associated with the given Access Profile
		         * @summary List Access Profile\'s Entitlements
		         * @param {string} id ID of the containing Access Profile
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **name**: *eq, sw*  **attribute**: *eq, sw*  **value**: *eq, sw*  **created**: *gt, lt, ge, le*  **modified**: *gt, lt, ge, le*  **owner.id**: *eq, in*  **source.id**: *eq, in*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name, attribute, value, created, modified**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getAccessProfileEntitlements: function (id, limit, offset, count, filters, sorters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getAccessProfileEntitlements', 'id', id);
		                            localVarPath = "/access-profiles/{id}/entitlements"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns a list of Access Profiles.  A token with API, ORG_ADMIN, ROLE_ADMIN, ROLE_SUBADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		         * @summary List Access Profiles
		         * @param {string} [forSubadmin] If provided, filters the returned list according to what is visible to the indicated ROLE_SUBADMIN or SOURCE_SUBADMIN Identity. The value of the parameter is either an Identity ID, or the special value **me**, which is shorthand for the calling Identity\&#39;s ID.  A 400 Bad Request error is returned if the **for-subadmin** parameter is specified for an Identity that is not a subadmin.
		         * @param {number} [limit] Note that for this API the maximum value for limit is 50. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **name**: *eq, sw*  **created**: *gt, lt, ge, le*  **modified**: *gt, lt, ge, le*  **owner.id**: *eq, in*  **requestable**: *eq*  **source.id**: *eq, in*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name, created, modified**
		         * @param {string} [forSegmentIds] If present and not empty, additionally filters Access Profiles to those which are assigned to the Segment(s) with the specified IDs.  If segmentation is currently unavailable, specifying this parameter results in an error.
		         * @param {boolean} [includeUnsegmented] Whether or not the response list should contain unsegmented Access Profiles. If *for-segment-ids* is absent or empty, specifying *include-unsegmented* as false results in an error.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listAccessProfiles: function (forSubadmin, limit, offset, count, filters, sorters, forSegmentIds, includeUnsegmented, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/access-profiles";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (forSubadmin !== undefined) {
		                                localVarQueryParameter['for-subadmin'] = forSubadmin;
		                            }
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            if (forSegmentIds !== undefined) {
		                                localVarQueryParameter['for-segment-ids'] = forSegmentIds;
		                            }
		                            if (includeUnsegmented !== undefined) {
		                                localVarQueryParameter['include-unsegmented'] = includeUnsegmented;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API updates an existing Access Profile. The following fields are patchable: **name**, **description**, **enabled**, **owner**, **requestable**, **accessRequestConfig**, **revokeRequestConfig**, **segments**, **entitlements**, **provisioningCriteria** A token with API, ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API. In addition, a SOURCE_SUBADMIN may only use this API to patch Access Profiles which are associated with Sources they are able to administer. >  The maximum supported length for the description field is 2000 characters. Longer descriptions will be preserved for existing access profiles, however, any new access profiles as well as any updates to existing descriptions will be limited to 2000 characters.  > You can only add or replace **entitlements** that exist on the source that the access profile is attached to. You can use the **list entitlements** endpoint with the **filters** query parameter to get a list of available entitlements on the access profile\'s source.  >  Patching the value of the **requestable** field is only supported for customers enabled with the new Request Center. Otherwise, attempting to modify this field results in a 400 error.
		         * @summary Patch a specified Access Profile
		         * @param {string} id ID of the Access Profile to patch
		         * @param {Array<JsonPatchOperationBeta>} jsonPatchOperationBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchAccessProfile: function (id, jsonPatchOperationBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('patchAccessProfile', 'id', id);
		                            // verify required parameter 'jsonPatchOperationBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('patchAccessProfile', 'jsonPatchOperationBeta', jsonPatchOperationBeta);
		                            localVarPath = "/access-profiles/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PATCH' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json-patch+json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(jsonPatchOperationBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API initiates a bulk update of field requestable for one or more Access Profiles.  >  If any of the indicated Access Profiles is exists in Organization,then those Access Profiles will be added in **updated**     list of the response.Requestable field of these Access Profiles marked as **true** or **false**.  >  If any of the indicated Access Profiles is not does not exists in Organization,then those Access Profiles will be added in **notFound** list of the response. Access Profiles marked as **notFound** will not be updated. >  A token with API, ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API. In addition, a SOURCE_SUBADMIN may only use this API to update Access Profiles which are associated with Sources they are able to administer.
		         * @summary Update Access Profile(s) requestable field.
		         * @param {Array<AccessProfileBulkUpdateRequestInnerBeta>} accessProfileBulkUpdateRequestInnerBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateAccessProfilesInBulk: function (accessProfileBulkUpdateRequestInnerBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'accessProfileBulkUpdateRequestInnerBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('updateAccessProfilesInBulk', 'accessProfileBulkUpdateRequestInnerBeta', accessProfileBulkUpdateRequestInnerBeta);
		                            localVarPath = "/access-profiles/bulk-update-requestable";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(accessProfileBulkUpdateRequestInnerBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.AccessProfilesBetaApiAxiosParamCreator = AccessProfilesBetaApiAxiosParamCreator;
		/**
		 * AccessProfilesBetaApi - functional programming interface
		 * @export
		 */
		var AccessProfilesBetaApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.AccessProfilesBetaApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * This API creates an Access Profile. A token with API, ORG_ADMIN, ROLE_ADMIN, ROLE_SUBADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API. In addition, a token with only ROLE_SUBADMIN or SOURCE_SUBADMIN authority must be associated with the Access Profile\'s Source. The maximum supported length for the description field is 2000 characters. Longer descriptions will be preserved for existing access profiles, however, any new access profiles as well as any updates to existing descriptions will be limited to 2000 characters.
		         * @summary Create an Access Profile
		         * @param {AccessProfileBeta} accessProfileBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createAccessProfile: function (accessProfileBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.createAccessProfile(accessProfileBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API deletes an existing Access Profile.  The Access Profile must not be in use, for example, Access Profile can not be deleted if they belong to an Application, Life Cycle State or a Role. If it is, a 400 error is returned.  A token with API, ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to invoke this API. In addition, a SOURCE_SUBADMIN token must be able to administer the Source associated with the Access Profile.
		         * @summary Delete the specified Access Profile
		         * @param {string} id ID of the Access Profile to delete
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteAccessProfile: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.deleteAccessProfile(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API initiates a bulk deletion of one or more Access Profiles.  By default, if any of the indicated Access Profiles are in use, no deletions will be performed and the **inUse** field of the response indicates the usages that must be removed first. If the request field **bestEffortOnly** is **true**, however, usages are reported in the **inUse** response field but all other indicated Access Profiles will be deleted.  A token with API, ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API. In addition, a SOURCE_SUBADMIN may only use this API to delete Access Profiles which are associated with Sources they are able to administer.
		         * @summary Delete Access Profile(s)
		         * @param {AccessProfileBulkDeleteRequestBeta} accessProfileBulkDeleteRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteAccessProfilesInBulk: function (accessProfileBulkDeleteRequestBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.deleteAccessProfilesInBulk(accessProfileBulkDeleteRequestBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns an Access Profile by its ID.  A token with API, ORG_ADMIN, ROLE_ADMIN, ROLE_SUBADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		         * @summary Get an Access Profile
		         * @param {string} id ID of the Access Profile
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getAccessProfile: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getAccessProfile(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API lists the Entitlements associated with a given Access Profile  A token with API, ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to invoke this API. In addition, a token with SOURCE_SUBADMIN authority must have access to the Source associated with the given Access Profile
		         * @summary List Access Profile\'s Entitlements
		         * @param {string} id ID of the containing Access Profile
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **name**: *eq, sw*  **attribute**: *eq, sw*  **value**: *eq, sw*  **created**: *gt, lt, ge, le*  **modified**: *gt, lt, ge, le*  **owner.id**: *eq, in*  **source.id**: *eq, in*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name, attribute, value, created, modified**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getAccessProfileEntitlements: function (id, limit, offset, count, filters, sorters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getAccessProfileEntitlements(id, limit, offset, count, filters, sorters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns a list of Access Profiles.  A token with API, ORG_ADMIN, ROLE_ADMIN, ROLE_SUBADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		         * @summary List Access Profiles
		         * @param {string} [forSubadmin] If provided, filters the returned list according to what is visible to the indicated ROLE_SUBADMIN or SOURCE_SUBADMIN Identity. The value of the parameter is either an Identity ID, or the special value **me**, which is shorthand for the calling Identity\&#39;s ID.  A 400 Bad Request error is returned if the **for-subadmin** parameter is specified for an Identity that is not a subadmin.
		         * @param {number} [limit] Note that for this API the maximum value for limit is 50. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **name**: *eq, sw*  **created**: *gt, lt, ge, le*  **modified**: *gt, lt, ge, le*  **owner.id**: *eq, in*  **requestable**: *eq*  **source.id**: *eq, in*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name, created, modified**
		         * @param {string} [forSegmentIds] If present and not empty, additionally filters Access Profiles to those which are assigned to the Segment(s) with the specified IDs.  If segmentation is currently unavailable, specifying this parameter results in an error.
		         * @param {boolean} [includeUnsegmented] Whether or not the response list should contain unsegmented Access Profiles. If *for-segment-ids* is absent or empty, specifying *include-unsegmented* as false results in an error.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listAccessProfiles: function (forSubadmin, limit, offset, count, filters, sorters, forSegmentIds, includeUnsegmented, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listAccessProfiles(forSubadmin, limit, offset, count, filters, sorters, forSegmentIds, includeUnsegmented, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API updates an existing Access Profile. The following fields are patchable: **name**, **description**, **enabled**, **owner**, **requestable**, **accessRequestConfig**, **revokeRequestConfig**, **segments**, **entitlements**, **provisioningCriteria** A token with API, ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API. In addition, a SOURCE_SUBADMIN may only use this API to patch Access Profiles which are associated with Sources they are able to administer. >  The maximum supported length for the description field is 2000 characters. Longer descriptions will be preserved for existing access profiles, however, any new access profiles as well as any updates to existing descriptions will be limited to 2000 characters.  > You can only add or replace **entitlements** that exist on the source that the access profile is attached to. You can use the **list entitlements** endpoint with the **filters** query parameter to get a list of available entitlements on the access profile\'s source.  >  Patching the value of the **requestable** field is only supported for customers enabled with the new Request Center. Otherwise, attempting to modify this field results in a 400 error.
		         * @summary Patch a specified Access Profile
		         * @param {string} id ID of the Access Profile to patch
		         * @param {Array<JsonPatchOperationBeta>} jsonPatchOperationBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchAccessProfile: function (id, jsonPatchOperationBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.patchAccessProfile(id, jsonPatchOperationBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API initiates a bulk update of field requestable for one or more Access Profiles.  >  If any of the indicated Access Profiles is exists in Organization,then those Access Profiles will be added in **updated**     list of the response.Requestable field of these Access Profiles marked as **true** or **false**.  >  If any of the indicated Access Profiles is not does not exists in Organization,then those Access Profiles will be added in **notFound** list of the response. Access Profiles marked as **notFound** will not be updated. >  A token with API, ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API. In addition, a SOURCE_SUBADMIN may only use this API to update Access Profiles which are associated with Sources they are able to administer.
		         * @summary Update Access Profile(s) requestable field.
		         * @param {Array<AccessProfileBulkUpdateRequestInnerBeta>} accessProfileBulkUpdateRequestInnerBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateAccessProfilesInBulk: function (accessProfileBulkUpdateRequestInnerBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.updateAccessProfilesInBulk(accessProfileBulkUpdateRequestInnerBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.AccessProfilesBetaApiFp = AccessProfilesBetaApiFp;
		/**
		 * AccessProfilesBetaApi - factory interface
		 * @export
		 */
		var AccessProfilesBetaApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.AccessProfilesBetaApiFp)(configuration);
		    return {
		        /**
		         * This API creates an Access Profile. A token with API, ORG_ADMIN, ROLE_ADMIN, ROLE_SUBADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API. In addition, a token with only ROLE_SUBADMIN or SOURCE_SUBADMIN authority must be associated with the Access Profile\'s Source. The maximum supported length for the description field is 2000 characters. Longer descriptions will be preserved for existing access profiles, however, any new access profiles as well as any updates to existing descriptions will be limited to 2000 characters.
		         * @summary Create an Access Profile
		         * @param {AccessProfileBeta} accessProfileBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createAccessProfile: function (accessProfileBeta, axiosOptions) {
		            return localVarFp.createAccessProfile(accessProfileBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API deletes an existing Access Profile.  The Access Profile must not be in use, for example, Access Profile can not be deleted if they belong to an Application, Life Cycle State or a Role. If it is, a 400 error is returned.  A token with API, ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to invoke this API. In addition, a SOURCE_SUBADMIN token must be able to administer the Source associated with the Access Profile.
		         * @summary Delete the specified Access Profile
		         * @param {string} id ID of the Access Profile to delete
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteAccessProfile: function (id, axiosOptions) {
		            return localVarFp.deleteAccessProfile(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API initiates a bulk deletion of one or more Access Profiles.  By default, if any of the indicated Access Profiles are in use, no deletions will be performed and the **inUse** field of the response indicates the usages that must be removed first. If the request field **bestEffortOnly** is **true**, however, usages are reported in the **inUse** response field but all other indicated Access Profiles will be deleted.  A token with API, ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API. In addition, a SOURCE_SUBADMIN may only use this API to delete Access Profiles which are associated with Sources they are able to administer.
		         * @summary Delete Access Profile(s)
		         * @param {AccessProfileBulkDeleteRequestBeta} accessProfileBulkDeleteRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteAccessProfilesInBulk: function (accessProfileBulkDeleteRequestBeta, axiosOptions) {
		            return localVarFp.deleteAccessProfilesInBulk(accessProfileBulkDeleteRequestBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API returns an Access Profile by its ID.  A token with API, ORG_ADMIN, ROLE_ADMIN, ROLE_SUBADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		         * @summary Get an Access Profile
		         * @param {string} id ID of the Access Profile
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getAccessProfile: function (id, axiosOptions) {
		            return localVarFp.getAccessProfile(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API lists the Entitlements associated with a given Access Profile  A token with API, ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to invoke this API. In addition, a token with SOURCE_SUBADMIN authority must have access to the Source associated with the given Access Profile
		         * @summary List Access Profile\'s Entitlements
		         * @param {string} id ID of the containing Access Profile
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **name**: *eq, sw*  **attribute**: *eq, sw*  **value**: *eq, sw*  **created**: *gt, lt, ge, le*  **modified**: *gt, lt, ge, le*  **owner.id**: *eq, in*  **source.id**: *eq, in*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name, attribute, value, created, modified**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getAccessProfileEntitlements: function (id, limit, offset, count, filters, sorters, axiosOptions) {
		            return localVarFp.getAccessProfileEntitlements(id, limit, offset, count, filters, sorters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API returns a list of Access Profiles.  A token with API, ORG_ADMIN, ROLE_ADMIN, ROLE_SUBADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		         * @summary List Access Profiles
		         * @param {string} [forSubadmin] If provided, filters the returned list according to what is visible to the indicated ROLE_SUBADMIN or SOURCE_SUBADMIN Identity. The value of the parameter is either an Identity ID, or the special value **me**, which is shorthand for the calling Identity\&#39;s ID.  A 400 Bad Request error is returned if the **for-subadmin** parameter is specified for an Identity that is not a subadmin.
		         * @param {number} [limit] Note that for this API the maximum value for limit is 50. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **name**: *eq, sw*  **created**: *gt, lt, ge, le*  **modified**: *gt, lt, ge, le*  **owner.id**: *eq, in*  **requestable**: *eq*  **source.id**: *eq, in*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name, created, modified**
		         * @param {string} [forSegmentIds] If present and not empty, additionally filters Access Profiles to those which are assigned to the Segment(s) with the specified IDs.  If segmentation is currently unavailable, specifying this parameter results in an error.
		         * @param {boolean} [includeUnsegmented] Whether or not the response list should contain unsegmented Access Profiles. If *for-segment-ids* is absent or empty, specifying *include-unsegmented* as false results in an error.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listAccessProfiles: function (forSubadmin, limit, offset, count, filters, sorters, forSegmentIds, includeUnsegmented, axiosOptions) {
		            return localVarFp.listAccessProfiles(forSubadmin, limit, offset, count, filters, sorters, forSegmentIds, includeUnsegmented, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API updates an existing Access Profile. The following fields are patchable: **name**, **description**, **enabled**, **owner**, **requestable**, **accessRequestConfig**, **revokeRequestConfig**, **segments**, **entitlements**, **provisioningCriteria** A token with API, ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API. In addition, a SOURCE_SUBADMIN may only use this API to patch Access Profiles which are associated with Sources they are able to administer. >  The maximum supported length for the description field is 2000 characters. Longer descriptions will be preserved for existing access profiles, however, any new access profiles as well as any updates to existing descriptions will be limited to 2000 characters.  > You can only add or replace **entitlements** that exist on the source that the access profile is attached to. You can use the **list entitlements** endpoint with the **filters** query parameter to get a list of available entitlements on the access profile\'s source.  >  Patching the value of the **requestable** field is only supported for customers enabled with the new Request Center. Otherwise, attempting to modify this field results in a 400 error.
		         * @summary Patch a specified Access Profile
		         * @param {string} id ID of the Access Profile to patch
		         * @param {Array<JsonPatchOperationBeta>} jsonPatchOperationBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchAccessProfile: function (id, jsonPatchOperationBeta, axiosOptions) {
		            return localVarFp.patchAccessProfile(id, jsonPatchOperationBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API initiates a bulk update of field requestable for one or more Access Profiles.  >  If any of the indicated Access Profiles is exists in Organization,then those Access Profiles will be added in **updated**     list of the response.Requestable field of these Access Profiles marked as **true** or **false**.  >  If any of the indicated Access Profiles is not does not exists in Organization,then those Access Profiles will be added in **notFound** list of the response. Access Profiles marked as **notFound** will not be updated. >  A token with API, ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API. In addition, a SOURCE_SUBADMIN may only use this API to update Access Profiles which are associated with Sources they are able to administer.
		         * @summary Update Access Profile(s) requestable field.
		         * @param {Array<AccessProfileBulkUpdateRequestInnerBeta>} accessProfileBulkUpdateRequestInnerBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateAccessProfilesInBulk: function (accessProfileBulkUpdateRequestInnerBeta, axiosOptions) {
		            return localVarFp.updateAccessProfilesInBulk(accessProfileBulkUpdateRequestInnerBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.AccessProfilesBetaApiFactory = AccessProfilesBetaApiFactory;
		/**
		 * AccessProfilesBetaApi - object-oriented interface
		 * @export
		 * @class AccessProfilesBetaApi
		 * @extends {BaseAPI}
		 */
		var AccessProfilesBetaApi = /** @class */ (function (_super) {
		    __extends(AccessProfilesBetaApi, _super);
		    function AccessProfilesBetaApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * This API creates an Access Profile. A token with API, ORG_ADMIN, ROLE_ADMIN, ROLE_SUBADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API. In addition, a token with only ROLE_SUBADMIN or SOURCE_SUBADMIN authority must be associated with the Access Profile\'s Source. The maximum supported length for the description field is 2000 characters. Longer descriptions will be preserved for existing access profiles, however, any new access profiles as well as any updates to existing descriptions will be limited to 2000 characters.
		     * @summary Create an Access Profile
		     * @param {AccessProfilesBetaApiCreateAccessProfileRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof AccessProfilesBetaApi
		     */
		    AccessProfilesBetaApi.prototype.createAccessProfile = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.AccessProfilesBetaApiFp)(this.configuration).createAccessProfile(requestParameters.accessProfileBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API deletes an existing Access Profile.  The Access Profile must not be in use, for example, Access Profile can not be deleted if they belong to an Application, Life Cycle State or a Role. If it is, a 400 error is returned.  A token with API, ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to invoke this API. In addition, a SOURCE_SUBADMIN token must be able to administer the Source associated with the Access Profile.
		     * @summary Delete the specified Access Profile
		     * @param {AccessProfilesBetaApiDeleteAccessProfileRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof AccessProfilesBetaApi
		     */
		    AccessProfilesBetaApi.prototype.deleteAccessProfile = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.AccessProfilesBetaApiFp)(this.configuration).deleteAccessProfile(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API initiates a bulk deletion of one or more Access Profiles.  By default, if any of the indicated Access Profiles are in use, no deletions will be performed and the **inUse** field of the response indicates the usages that must be removed first. If the request field **bestEffortOnly** is **true**, however, usages are reported in the **inUse** response field but all other indicated Access Profiles will be deleted.  A token with API, ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API. In addition, a SOURCE_SUBADMIN may only use this API to delete Access Profiles which are associated with Sources they are able to administer.
		     * @summary Delete Access Profile(s)
		     * @param {AccessProfilesBetaApiDeleteAccessProfilesInBulkRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof AccessProfilesBetaApi
		     */
		    AccessProfilesBetaApi.prototype.deleteAccessProfilesInBulk = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.AccessProfilesBetaApiFp)(this.configuration).deleteAccessProfilesInBulk(requestParameters.accessProfileBulkDeleteRequestBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API returns an Access Profile by its ID.  A token with API, ORG_ADMIN, ROLE_ADMIN, ROLE_SUBADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		     * @summary Get an Access Profile
		     * @param {AccessProfilesBetaApiGetAccessProfileRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof AccessProfilesBetaApi
		     */
		    AccessProfilesBetaApi.prototype.getAccessProfile = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.AccessProfilesBetaApiFp)(this.configuration).getAccessProfile(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API lists the Entitlements associated with a given Access Profile  A token with API, ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to invoke this API. In addition, a token with SOURCE_SUBADMIN authority must have access to the Source associated with the given Access Profile
		     * @summary List Access Profile\'s Entitlements
		     * @param {AccessProfilesBetaApiGetAccessProfileEntitlementsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof AccessProfilesBetaApi
		     */
		    AccessProfilesBetaApi.prototype.getAccessProfileEntitlements = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.AccessProfilesBetaApiFp)(this.configuration).getAccessProfileEntitlements(requestParameters.id, requestParameters.limit, requestParameters.offset, requestParameters.count, requestParameters.filters, requestParameters.sorters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API returns a list of Access Profiles.  A token with API, ORG_ADMIN, ROLE_ADMIN, ROLE_SUBADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		     * @summary List Access Profiles
		     * @param {AccessProfilesBetaApiListAccessProfilesRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof AccessProfilesBetaApi
		     */
		    AccessProfilesBetaApi.prototype.listAccessProfiles = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.AccessProfilesBetaApiFp)(this.configuration).listAccessProfiles(requestParameters.forSubadmin, requestParameters.limit, requestParameters.offset, requestParameters.count, requestParameters.filters, requestParameters.sorters, requestParameters.forSegmentIds, requestParameters.includeUnsegmented, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API updates an existing Access Profile. The following fields are patchable: **name**, **description**, **enabled**, **owner**, **requestable**, **accessRequestConfig**, **revokeRequestConfig**, **segments**, **entitlements**, **provisioningCriteria** A token with API, ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API. In addition, a SOURCE_SUBADMIN may only use this API to patch Access Profiles which are associated with Sources they are able to administer. >  The maximum supported length for the description field is 2000 characters. Longer descriptions will be preserved for existing access profiles, however, any new access profiles as well as any updates to existing descriptions will be limited to 2000 characters.  > You can only add or replace **entitlements** that exist on the source that the access profile is attached to. You can use the **list entitlements** endpoint with the **filters** query parameter to get a list of available entitlements on the access profile\'s source.  >  Patching the value of the **requestable** field is only supported for customers enabled with the new Request Center. Otherwise, attempting to modify this field results in a 400 error.
		     * @summary Patch a specified Access Profile
		     * @param {AccessProfilesBetaApiPatchAccessProfileRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof AccessProfilesBetaApi
		     */
		    AccessProfilesBetaApi.prototype.patchAccessProfile = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.AccessProfilesBetaApiFp)(this.configuration).patchAccessProfile(requestParameters.id, requestParameters.jsonPatchOperationBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API initiates a bulk update of field requestable for one or more Access Profiles.  >  If any of the indicated Access Profiles is exists in Organization,then those Access Profiles will be added in **updated**     list of the response.Requestable field of these Access Profiles marked as **true** or **false**.  >  If any of the indicated Access Profiles is not does not exists in Organization,then those Access Profiles will be added in **notFound** list of the response. Access Profiles marked as **notFound** will not be updated. >  A token with API, ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API. In addition, a SOURCE_SUBADMIN may only use this API to update Access Profiles which are associated with Sources they are able to administer.
		     * @summary Update Access Profile(s) requestable field.
		     * @param {AccessProfilesBetaApiUpdateAccessProfilesInBulkRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof AccessProfilesBetaApi
		     */
		    AccessProfilesBetaApi.prototype.updateAccessProfilesInBulk = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.AccessProfilesBetaApiFp)(this.configuration).updateAccessProfilesInBulk(requestParameters.accessProfileBulkUpdateRequestInnerBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return AccessProfilesBetaApi;
		}(base_1.BaseAPI));
		exports.AccessProfilesBetaApi = AccessProfilesBetaApi;
		/**
		 * AccessRequestApprovalsBetaApi - axios parameter creator
		 * @export
		 */
		var AccessRequestApprovalsBetaApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * This endpoint approves an access request approval. Only the owner of the approval and ORG_ADMIN users are allowed to perform this action.
		         * @summary Approves an access request approval.
		         * @param {string} approvalId The id of the approval.
		         * @param {CommentDtoBeta} [commentDtoBeta] Reviewer\&#39;s comment.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        approveAccessRequest: function (approvalId, commentDtoBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'approvalId' is not null or undefined
		                            (0, common_1.assertParamExists)('approveAccessRequest', 'approvalId', approvalId);
		                            localVarPath = "/access-request-approvals/{approvalId}/approve"
		                                .replace("{".concat("approvalId", "}"), encodeURIComponent(String(approvalId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(commentDtoBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This endpoint forwards an access request approval. Only the owner of the approval and ORG_ADMIN users are allowed to perform this action.
		         * @summary Forwards an access request approval to a new owner.
		         * @param {string} approvalId The id of the approval.
		         * @param {ForwardApprovalDtoBeta} forwardApprovalDtoBeta Information about the forwarded approval.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        forwardAccessRequest: function (approvalId, forwardApprovalDtoBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'approvalId' is not null or undefined
		                            (0, common_1.assertParamExists)('forwardAccessRequest', 'approvalId', approvalId);
		                            // verify required parameter 'forwardApprovalDtoBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('forwardAccessRequest', 'forwardApprovalDtoBeta', forwardApprovalDtoBeta);
		                            localVarPath = "/access-request-approvals/{approvalId}/forward"
		                                .replace("{".concat("approvalId", "}"), encodeURIComponent(String(approvalId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(forwardApprovalDtoBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This endpoint returns the number of pending, approved and rejected access requests approvals. See \"owner-id\" query parameter below for authorization info.
		         * @summary Get the number of pending, approved and rejected access requests approvals
		         * @param {string} [ownerId] The id of the owner or approver identity of the approvals. If present, the value returns approval summary for the specified identity.    * ORG_ADMIN users can call this with any identity ID value.    * ORG_ADMIN user can also fetch all the approvals in the org, when owner-id is not used.    * Non ORG_ADMIN users can only specify *me* or pass their own identity ID value.
		         * @param {string} [fromDate] From date is the date and time from which the results will be shown. It should be in a valid ISO-8601 format  example: from-date&#x3D;2020-03-19T19:59:11Z
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getAccessRequestApprovalSummary: function (ownerId, fromDate, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/access-request-approvals/approval-summary";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (ownerId !== undefined) {
		                                localVarQueryParameter['owner-id'] = ownerId;
		                            }
		                            if (fromDate !== undefined) {
		                                localVarQueryParameter['from-date'] = fromDate;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This endpoint returns list of completed approvals. See *owner-id* query parameter below for authorization info.
		         * @summary Completed Access Request Approvals List
		         * @param {string} [ownerId] If present, the value returns only completed approvals for the specified identity.    * ORG_ADMIN users can call this with any identity ID value.    * ORG_ADMIN users can also fetch all the approvals in the org, when owner-id is not used.    * Non-ORG_ADMIN users can only specify *me* or pass their own identity ID value.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in, ge, gt, le, lt, ne, isnull, sw*  **requestedFor.id**: *eq, in, ge, gt, le, lt, ne, isnull, sw*  **modified**: *gt, lt, ge, le, eq, in, ne, sw*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **created, modified**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listCompletedApprovals: function (ownerId, limit, offset, count, filters, sorters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/access-request-approvals/completed";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (ownerId !== undefined) {
		                                localVarQueryParameter['owner-id'] = ownerId;
		                            }
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This endpoint returns a list of pending approvals. See \"owner-id\" query parameter below for authorization info.
		         * @summary Pending Access Request Approvals List
		         * @param {string} [ownerId] If present, the value returns only pending approvals for the specified identity.    * ORG_ADMIN users can call this with any identity ID value.    * ORG_ADMIN users can also fetch all the approvals in the org, when owner-id is not used.    * Non-ORG_ADMIN users can only specify *me* or pass their own identity ID value.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **requestedFor.id**: *eq, in*  **modified**: *gt, lt, ge, le, eq, in*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **created, modified**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listPendingApprovals: function (ownerId, limit, offset, count, filters, sorters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/access-request-approvals/pending";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (ownerId !== undefined) {
		                                localVarQueryParameter['owner-id'] = ownerId;
		                            }
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This endpoint rejects an access request approval. Only the owner of the approval and admin users are allowed to perform this action.
		         * @summary Rejects an access request approval.
		         * @param {string} approvalId The id of the approval.
		         * @param {CommentDtoBeta} [commentDtoBeta] Reviewer\&#39;s comment.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        rejectAccessRequest: function (approvalId, commentDtoBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'approvalId' is not null or undefined
		                            (0, common_1.assertParamExists)('rejectAccessRequest', 'approvalId', approvalId);
		                            localVarPath = "/access-request-approvals/{approvalId}/reject"
		                                .replace("{".concat("approvalId", "}"), encodeURIComponent(String(approvalId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(commentDtoBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.AccessRequestApprovalsBetaApiAxiosParamCreator = AccessRequestApprovalsBetaApiAxiosParamCreator;
		/**
		 * AccessRequestApprovalsBetaApi - functional programming interface
		 * @export
		 */
		var AccessRequestApprovalsBetaApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.AccessRequestApprovalsBetaApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * This endpoint approves an access request approval. Only the owner of the approval and ORG_ADMIN users are allowed to perform this action.
		         * @summary Approves an access request approval.
		         * @param {string} approvalId The id of the approval.
		         * @param {CommentDtoBeta} [commentDtoBeta] Reviewer\&#39;s comment.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        approveAccessRequest: function (approvalId, commentDtoBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.approveAccessRequest(approvalId, commentDtoBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This endpoint forwards an access request approval. Only the owner of the approval and ORG_ADMIN users are allowed to perform this action.
		         * @summary Forwards an access request approval to a new owner.
		         * @param {string} approvalId The id of the approval.
		         * @param {ForwardApprovalDtoBeta} forwardApprovalDtoBeta Information about the forwarded approval.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        forwardAccessRequest: function (approvalId, forwardApprovalDtoBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.forwardAccessRequest(approvalId, forwardApprovalDtoBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This endpoint returns the number of pending, approved and rejected access requests approvals. See \"owner-id\" query parameter below for authorization info.
		         * @summary Get the number of pending, approved and rejected access requests approvals
		         * @param {string} [ownerId] The id of the owner or approver identity of the approvals. If present, the value returns approval summary for the specified identity.    * ORG_ADMIN users can call this with any identity ID value.    * ORG_ADMIN user can also fetch all the approvals in the org, when owner-id is not used.    * Non ORG_ADMIN users can only specify *me* or pass their own identity ID value.
		         * @param {string} [fromDate] From date is the date and time from which the results will be shown. It should be in a valid ISO-8601 format  example: from-date&#x3D;2020-03-19T19:59:11Z
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getAccessRequestApprovalSummary: function (ownerId, fromDate, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getAccessRequestApprovalSummary(ownerId, fromDate, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This endpoint returns list of completed approvals. See *owner-id* query parameter below for authorization info.
		         * @summary Completed Access Request Approvals List
		         * @param {string} [ownerId] If present, the value returns only completed approvals for the specified identity.    * ORG_ADMIN users can call this with any identity ID value.    * ORG_ADMIN users can also fetch all the approvals in the org, when owner-id is not used.    * Non-ORG_ADMIN users can only specify *me* or pass their own identity ID value.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in, ge, gt, le, lt, ne, isnull, sw*  **requestedFor.id**: *eq, in, ge, gt, le, lt, ne, isnull, sw*  **modified**: *gt, lt, ge, le, eq, in, ne, sw*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **created, modified**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listCompletedApprovals: function (ownerId, limit, offset, count, filters, sorters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listCompletedApprovals(ownerId, limit, offset, count, filters, sorters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This endpoint returns a list of pending approvals. See \"owner-id\" query parameter below for authorization info.
		         * @summary Pending Access Request Approvals List
		         * @param {string} [ownerId] If present, the value returns only pending approvals for the specified identity.    * ORG_ADMIN users can call this with any identity ID value.    * ORG_ADMIN users can also fetch all the approvals in the org, when owner-id is not used.    * Non-ORG_ADMIN users can only specify *me* or pass their own identity ID value.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **requestedFor.id**: *eq, in*  **modified**: *gt, lt, ge, le, eq, in*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **created, modified**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listPendingApprovals: function (ownerId, limit, offset, count, filters, sorters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listPendingApprovals(ownerId, limit, offset, count, filters, sorters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This endpoint rejects an access request approval. Only the owner of the approval and admin users are allowed to perform this action.
		         * @summary Rejects an access request approval.
		         * @param {string} approvalId The id of the approval.
		         * @param {CommentDtoBeta} [commentDtoBeta] Reviewer\&#39;s comment.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        rejectAccessRequest: function (approvalId, commentDtoBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.rejectAccessRequest(approvalId, commentDtoBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.AccessRequestApprovalsBetaApiFp = AccessRequestApprovalsBetaApiFp;
		/**
		 * AccessRequestApprovalsBetaApi - factory interface
		 * @export
		 */
		var AccessRequestApprovalsBetaApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.AccessRequestApprovalsBetaApiFp)(configuration);
		    return {
		        /**
		         * This endpoint approves an access request approval. Only the owner of the approval and ORG_ADMIN users are allowed to perform this action.
		         * @summary Approves an access request approval.
		         * @param {string} approvalId The id of the approval.
		         * @param {CommentDtoBeta} [commentDtoBeta] Reviewer\&#39;s comment.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        approveAccessRequest: function (approvalId, commentDtoBeta, axiosOptions) {
		            return localVarFp.approveAccessRequest(approvalId, commentDtoBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This endpoint forwards an access request approval. Only the owner of the approval and ORG_ADMIN users are allowed to perform this action.
		         * @summary Forwards an access request approval to a new owner.
		         * @param {string} approvalId The id of the approval.
		         * @param {ForwardApprovalDtoBeta} forwardApprovalDtoBeta Information about the forwarded approval.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        forwardAccessRequest: function (approvalId, forwardApprovalDtoBeta, axiosOptions) {
		            return localVarFp.forwardAccessRequest(approvalId, forwardApprovalDtoBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This endpoint returns the number of pending, approved and rejected access requests approvals. See \"owner-id\" query parameter below for authorization info.
		         * @summary Get the number of pending, approved and rejected access requests approvals
		         * @param {string} [ownerId] The id of the owner or approver identity of the approvals. If present, the value returns approval summary for the specified identity.    * ORG_ADMIN users can call this with any identity ID value.    * ORG_ADMIN user can also fetch all the approvals in the org, when owner-id is not used.    * Non ORG_ADMIN users can only specify *me* or pass their own identity ID value.
		         * @param {string} [fromDate] From date is the date and time from which the results will be shown. It should be in a valid ISO-8601 format  example: from-date&#x3D;2020-03-19T19:59:11Z
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getAccessRequestApprovalSummary: function (ownerId, fromDate, axiosOptions) {
		            return localVarFp.getAccessRequestApprovalSummary(ownerId, fromDate, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This endpoint returns list of completed approvals. See *owner-id* query parameter below for authorization info.
		         * @summary Completed Access Request Approvals List
		         * @param {string} [ownerId] If present, the value returns only completed approvals for the specified identity.    * ORG_ADMIN users can call this with any identity ID value.    * ORG_ADMIN users can also fetch all the approvals in the org, when owner-id is not used.    * Non-ORG_ADMIN users can only specify *me* or pass their own identity ID value.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in, ge, gt, le, lt, ne, isnull, sw*  **requestedFor.id**: *eq, in, ge, gt, le, lt, ne, isnull, sw*  **modified**: *gt, lt, ge, le, eq, in, ne, sw*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **created, modified**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listCompletedApprovals: function (ownerId, limit, offset, count, filters, sorters, axiosOptions) {
		            return localVarFp.listCompletedApprovals(ownerId, limit, offset, count, filters, sorters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This endpoint returns a list of pending approvals. See \"owner-id\" query parameter below for authorization info.
		         * @summary Pending Access Request Approvals List
		         * @param {string} [ownerId] If present, the value returns only pending approvals for the specified identity.    * ORG_ADMIN users can call this with any identity ID value.    * ORG_ADMIN users can also fetch all the approvals in the org, when owner-id is not used.    * Non-ORG_ADMIN users can only specify *me* or pass their own identity ID value.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **requestedFor.id**: *eq, in*  **modified**: *gt, lt, ge, le, eq, in*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **created, modified**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listPendingApprovals: function (ownerId, limit, offset, count, filters, sorters, axiosOptions) {
		            return localVarFp.listPendingApprovals(ownerId, limit, offset, count, filters, sorters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This endpoint rejects an access request approval. Only the owner of the approval and admin users are allowed to perform this action.
		         * @summary Rejects an access request approval.
		         * @param {string} approvalId The id of the approval.
		         * @param {CommentDtoBeta} [commentDtoBeta] Reviewer\&#39;s comment.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        rejectAccessRequest: function (approvalId, commentDtoBeta, axiosOptions) {
		            return localVarFp.rejectAccessRequest(approvalId, commentDtoBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.AccessRequestApprovalsBetaApiFactory = AccessRequestApprovalsBetaApiFactory;
		/**
		 * AccessRequestApprovalsBetaApi - object-oriented interface
		 * @export
		 * @class AccessRequestApprovalsBetaApi
		 * @extends {BaseAPI}
		 */
		var AccessRequestApprovalsBetaApi = /** @class */ (function (_super) {
		    __extends(AccessRequestApprovalsBetaApi, _super);
		    function AccessRequestApprovalsBetaApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * This endpoint approves an access request approval. Only the owner of the approval and ORG_ADMIN users are allowed to perform this action.
		     * @summary Approves an access request approval.
		     * @param {AccessRequestApprovalsBetaApiApproveAccessRequestRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof AccessRequestApprovalsBetaApi
		     */
		    AccessRequestApprovalsBetaApi.prototype.approveAccessRequest = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.AccessRequestApprovalsBetaApiFp)(this.configuration).approveAccessRequest(requestParameters.approvalId, requestParameters.commentDtoBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This endpoint forwards an access request approval. Only the owner of the approval and ORG_ADMIN users are allowed to perform this action.
		     * @summary Forwards an access request approval to a new owner.
		     * @param {AccessRequestApprovalsBetaApiForwardAccessRequestRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof AccessRequestApprovalsBetaApi
		     */
		    AccessRequestApprovalsBetaApi.prototype.forwardAccessRequest = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.AccessRequestApprovalsBetaApiFp)(this.configuration).forwardAccessRequest(requestParameters.approvalId, requestParameters.forwardApprovalDtoBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This endpoint returns the number of pending, approved and rejected access requests approvals. See \"owner-id\" query parameter below for authorization info.
		     * @summary Get the number of pending, approved and rejected access requests approvals
		     * @param {AccessRequestApprovalsBetaApiGetAccessRequestApprovalSummaryRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof AccessRequestApprovalsBetaApi
		     */
		    AccessRequestApprovalsBetaApi.prototype.getAccessRequestApprovalSummary = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.AccessRequestApprovalsBetaApiFp)(this.configuration).getAccessRequestApprovalSummary(requestParameters.ownerId, requestParameters.fromDate, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This endpoint returns list of completed approvals. See *owner-id* query parameter below for authorization info.
		     * @summary Completed Access Request Approvals List
		     * @param {AccessRequestApprovalsBetaApiListCompletedApprovalsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof AccessRequestApprovalsBetaApi
		     */
		    AccessRequestApprovalsBetaApi.prototype.listCompletedApprovals = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.AccessRequestApprovalsBetaApiFp)(this.configuration).listCompletedApprovals(requestParameters.ownerId, requestParameters.limit, requestParameters.offset, requestParameters.count, requestParameters.filters, requestParameters.sorters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This endpoint returns a list of pending approvals. See \"owner-id\" query parameter below for authorization info.
		     * @summary Pending Access Request Approvals List
		     * @param {AccessRequestApprovalsBetaApiListPendingApprovalsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof AccessRequestApprovalsBetaApi
		     */
		    AccessRequestApprovalsBetaApi.prototype.listPendingApprovals = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.AccessRequestApprovalsBetaApiFp)(this.configuration).listPendingApprovals(requestParameters.ownerId, requestParameters.limit, requestParameters.offset, requestParameters.count, requestParameters.filters, requestParameters.sorters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This endpoint rejects an access request approval. Only the owner of the approval and admin users are allowed to perform this action.
		     * @summary Rejects an access request approval.
		     * @param {AccessRequestApprovalsBetaApiRejectAccessRequestRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof AccessRequestApprovalsBetaApi
		     */
		    AccessRequestApprovalsBetaApi.prototype.rejectAccessRequest = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.AccessRequestApprovalsBetaApiFp)(this.configuration).rejectAccessRequest(requestParameters.approvalId, requestParameters.commentDtoBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return AccessRequestApprovalsBetaApi;
		}(base_1.BaseAPI));
		exports.AccessRequestApprovalsBetaApi = AccessRequestApprovalsBetaApi;
		/**
		 * AccessRequestIdentityMetricsBetaApi - axios parameter creator
		 * @export
		 */
		var AccessRequestIdentityMetricsBetaApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * Use this API to return information access metrics.
		         * @summary Return access request identity metrics
		         * @param {string} identityId Identity\&#39;s ID.
		         * @param {string} requestedObjectId Requested access item\&#39;s ID.
		         * @param {string} type Requested access item\&#39;s type.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getAccessRequestIdentityMetrics: function (identityId, requestedObjectId, type, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'identityId' is not null or undefined
		                            (0, common_1.assertParamExists)('getAccessRequestIdentityMetrics', 'identityId', identityId);
		                            // verify required parameter 'requestedObjectId' is not null or undefined
		                            (0, common_1.assertParamExists)('getAccessRequestIdentityMetrics', 'requestedObjectId', requestedObjectId);
		                            // verify required parameter 'type' is not null or undefined
		                            (0, common_1.assertParamExists)('getAccessRequestIdentityMetrics', 'type', type);
		                            localVarPath = "/access-request-identity-metrics/{identityId}/requested-objects/{requestedObjectId}/type/{type}"
		                                .replace("{".concat("identityId", "}"), encodeURIComponent(String(identityId)))
		                                .replace("{".concat("requestedObjectId", "}"), encodeURIComponent(String(requestedObjectId)))
		                                .replace("{".concat("type", "}"), encodeURIComponent(String(type)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.AccessRequestIdentityMetricsBetaApiAxiosParamCreator = AccessRequestIdentityMetricsBetaApiAxiosParamCreator;
		/**
		 * AccessRequestIdentityMetricsBetaApi - functional programming interface
		 * @export
		 */
		var AccessRequestIdentityMetricsBetaApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.AccessRequestIdentityMetricsBetaApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * Use this API to return information access metrics.
		         * @summary Return access request identity metrics
		         * @param {string} identityId Identity\&#39;s ID.
		         * @param {string} requestedObjectId Requested access item\&#39;s ID.
		         * @param {string} type Requested access item\&#39;s type.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getAccessRequestIdentityMetrics: function (identityId, requestedObjectId, type, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getAccessRequestIdentityMetrics(identityId, requestedObjectId, type, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.AccessRequestIdentityMetricsBetaApiFp = AccessRequestIdentityMetricsBetaApiFp;
		/**
		 * AccessRequestIdentityMetricsBetaApi - factory interface
		 * @export
		 */
		var AccessRequestIdentityMetricsBetaApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.AccessRequestIdentityMetricsBetaApiFp)(configuration);
		    return {
		        /**
		         * Use this API to return information access metrics.
		         * @summary Return access request identity metrics
		         * @param {string} identityId Identity\&#39;s ID.
		         * @param {string} requestedObjectId Requested access item\&#39;s ID.
		         * @param {string} type Requested access item\&#39;s type.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getAccessRequestIdentityMetrics: function (identityId, requestedObjectId, type, axiosOptions) {
		            return localVarFp.getAccessRequestIdentityMetrics(identityId, requestedObjectId, type, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.AccessRequestIdentityMetricsBetaApiFactory = AccessRequestIdentityMetricsBetaApiFactory;
		/**
		 * AccessRequestIdentityMetricsBetaApi - object-oriented interface
		 * @export
		 * @class AccessRequestIdentityMetricsBetaApi
		 * @extends {BaseAPI}
		 */
		var AccessRequestIdentityMetricsBetaApi = /** @class */ (function (_super) {
		    __extends(AccessRequestIdentityMetricsBetaApi, _super);
		    function AccessRequestIdentityMetricsBetaApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * Use this API to return information access metrics.
		     * @summary Return access request identity metrics
		     * @param {AccessRequestIdentityMetricsBetaApiGetAccessRequestIdentityMetricsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof AccessRequestIdentityMetricsBetaApi
		     */
		    AccessRequestIdentityMetricsBetaApi.prototype.getAccessRequestIdentityMetrics = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.AccessRequestIdentityMetricsBetaApiFp)(this.configuration).getAccessRequestIdentityMetrics(requestParameters.identityId, requestParameters.requestedObjectId, requestParameters.type, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return AccessRequestIdentityMetricsBetaApi;
		}(base_1.BaseAPI));
		exports.AccessRequestIdentityMetricsBetaApi = AccessRequestIdentityMetricsBetaApi;
		/**
		 * AccessRequestsBetaApi - axios parameter creator
		 * @export
		 */
		var AccessRequestsBetaApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * This API endpoint cancels a pending access request. An access request can be cancelled only if it has not passed the approval step. Any token with ORG_ADMIN authority or token of the user who originally requested the access request is required to cancel it.
		         * @summary Cancel Access Request
		         * @param {CancelAccessRequestBeta} cancelAccessRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        cancelAccessRequest: function (cancelAccessRequestBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'cancelAccessRequestBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('cancelAccessRequest', 'cancelAccessRequestBeta', cancelAccessRequestBeta);
		                            localVarPath = "/access-requests/cancel";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(cancelAccessRequestBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This endpoint closes access requests that are stuck in a pending state. It can be used throughout a request\'s lifecycle even after the approval state, unlike the [Cancel Access Request endpoint](https://developer.sailpoint.com/idn/api/v3/cancel-access-request/). A token with ORG_ADMIN authority is required.  To find pending access requests with the UI, navigate to Search and use this query: status: Pending AND \"Access Request\". Use the Column Chooser to select \'Tracking Number\', and use the \'Download\' button to export a CSV containing the tracking numbers.  To find pending access requests with the API, use the [List Account Activities endpoint](https://developer.sailpoint.com/idn/api/v3/list-account-activities/).  Input the IDs from either source.  To track the status of endpoint requests, navigate to Search and use this query: name:\"Close Identity Requests\". Search will include \"Close Identity Requests Started\" audits when requests are initiated and \"Close Identity Requests Completed\" audits when requests are completed. The completion audit will list the identity request IDs that finished in error.  This API triggers the [Provisioning Completed event trigger](https://developer.sailpoint.com/idn/docs/event-triggers/triggers/provisioning-completed/) for each access request that is closed.
		         * @summary Close Access Request
		         * @param {CloseAccessRequestBeta} closeAccessRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        closeAccessRequest: function (closeAccessRequestBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'closeAccessRequestBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('closeAccessRequest', 'closeAccessRequestBeta', closeAccessRequestBeta);
		                            localVarPath = "/access-requests/close";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(closeAccessRequestBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This submits the access request into IdentityNow, where it will follow any IdentityNow approval processes.  Access requests are processed asynchronously by IdentityNow.  A success response from this endpoint means the request has been submitted to IDN and is queued for processing.  Because this endpoint is asynchronous, it will not return an error if you submit duplicate access requests in quick succession, or you submit an access request for access that is already in progress, approved, or rejected. It is best practice to check for any existing access requests that reference the same access items before submitting a new access request.  This can be accomplished by using the [access request status](https://developer.sailpoint.com/idn/api/v3/list-access-request-status) or the [pending access request approvals](https://developer.sailpoint.com/idn/api/v3/list-pending-approvals) endpoints.  You can also use the [search API](https://developer.sailpoint.com/idn/api/v3/search) to check the existing access items that an identity has before submitting an access request to ensure you are not requesting access that is already granted.  There are two types of access request:  __GRANT_ACCESS__ * Can be requested for multiple identities in a single request. * Supports self request and request on behalf of other users. Refer to the [Get Access Request Configuration](https://developer.sailpoint.com/idn/api/v3/get-access-request-config) endpoint for request configuration options.   * Allows any authenticated token (except API) to call this endpoint to request to grant access to themselves. Depending on the configuration, a user can request access for others. * Roles, access profiles and entitlements can be requested. * While requesting entitlements, maximum of 25 entitlements and 10 recipients are allowed in a request.   __REVOKE_ACCESS__ * Can only be requested for a single identity at a time. * You cannot use an access request to revoke access from an identity if that access has been granted by role membership or by birthright provisioning.  * Does not support self request. Only manager can request to revoke access for their directly managed employees. * If a `removeDate` is specified, then the access will be removed on that date and time only for roles and access profiles. Entitlements are currently unsupported for `removeDate`. * Roles, access profiles, and entitlements can be requested for revocation. * Revoke requests for entitlements are limited to 1 entitlement per access request currently. * [Roles, Access Profiles] You can specify a `removeDate` if the access doesn\'t already have a sunset date. The `removeDate` must be a future date, in the UTC timezone.  * Allows a manager to request to revoke access for direct employees. A token with ORG_ADMIN authority can also request to revoke access from anyone.  >**Note:** There is no indication to the approver in the IdentityNow UI that the approval request is for a revoke action. Take this into consideration when calling this API.  A token with API authority cannot be used to call this endpoint.
		         * @summary Submit an Access Request
		         * @param {AccessRequestBeta} accessRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createAccessRequest: function (accessRequestBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'accessRequestBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('createAccessRequest', 'accessRequestBeta', accessRequestBeta);
		                            localVarPath = "/access-requests";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(accessRequestBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This endpoint returns the current access-request configuration.
		         * @summary Get Access Request Configuration
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getAccessRequestConfig: function (axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/access-request-config";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * The Access Request Status API returns a list of access request statuses based on the specified query parameters. Any token with any authority can request their own status. A token with ORG_ADMIN authority is required to call this API to get a list of statuses for other users.
		         * @summary Access Request Status
		         * @param {string} [requestedFor] Filter the results by the identity for which the requests were made. *me* indicates the current user. Mutually exclusive with *regarding-identity*.
		         * @param {string} [requestedBy] Filter the results by the identity that made the requests. *me* indicates the current user. Mutually exclusive with *regarding-identity*.
		         * @param {string} [regardingIdentity] Filter the results by the specified identity which is either the requester or target of the requests. *me* indicates the current user. Mutually exclusive with *requested-for* and *requested-by*.
		         * @param {string} [assignedTo] Filter the results by the specified identity which is the owner of the Identity Request Work Item. *me* indicates the current user.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.
		         * @param {number} [limit] Max number of results to return.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. Defaults to 0 if not specified.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **accountActivityItemId**: *eq, in, ge, gt, le, lt, ne, isnull, sw*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **created, modified, accountActivityItemId, name**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listAccessRequestStatus: function (requestedFor, requestedBy, regardingIdentity, assignedTo, count, limit, offset, filters, sorters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/access-request-status";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (requestedFor !== undefined) {
		                                localVarQueryParameter['requested-for'] = requestedFor;
		                            }
		                            if (requestedBy !== undefined) {
		                                localVarQueryParameter['requested-by'] = requestedBy;
		                            }
		                            if (regardingIdentity !== undefined) {
		                                localVarQueryParameter['regarding-identity'] = regardingIdentity;
		                            }
		                            if (assignedTo !== undefined) {
		                                localVarQueryParameter['assigned-to'] = assignedTo;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This endpoint replaces the current access-request configuration. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Update Access Request Configuration
		         * @param {AccessRequestConfigBeta} accessRequestConfigBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        setAccessRequestConfig: function (accessRequestConfigBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'accessRequestConfigBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('setAccessRequestConfig', 'accessRequestConfigBeta', accessRequestConfigBeta);
		                            localVarPath = "/access-request-config";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PUT' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(accessRequestConfigBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.AccessRequestsBetaApiAxiosParamCreator = AccessRequestsBetaApiAxiosParamCreator;
		/**
		 * AccessRequestsBetaApi - functional programming interface
		 * @export
		 */
		var AccessRequestsBetaApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.AccessRequestsBetaApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * This API endpoint cancels a pending access request. An access request can be cancelled only if it has not passed the approval step. Any token with ORG_ADMIN authority or token of the user who originally requested the access request is required to cancel it.
		         * @summary Cancel Access Request
		         * @param {CancelAccessRequestBeta} cancelAccessRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        cancelAccessRequest: function (cancelAccessRequestBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.cancelAccessRequest(cancelAccessRequestBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This endpoint closes access requests that are stuck in a pending state. It can be used throughout a request\'s lifecycle even after the approval state, unlike the [Cancel Access Request endpoint](https://developer.sailpoint.com/idn/api/v3/cancel-access-request/). A token with ORG_ADMIN authority is required.  To find pending access requests with the UI, navigate to Search and use this query: status: Pending AND \"Access Request\". Use the Column Chooser to select \'Tracking Number\', and use the \'Download\' button to export a CSV containing the tracking numbers.  To find pending access requests with the API, use the [List Account Activities endpoint](https://developer.sailpoint.com/idn/api/v3/list-account-activities/).  Input the IDs from either source.  To track the status of endpoint requests, navigate to Search and use this query: name:\"Close Identity Requests\". Search will include \"Close Identity Requests Started\" audits when requests are initiated and \"Close Identity Requests Completed\" audits when requests are completed. The completion audit will list the identity request IDs that finished in error.  This API triggers the [Provisioning Completed event trigger](https://developer.sailpoint.com/idn/docs/event-triggers/triggers/provisioning-completed/) for each access request that is closed.
		         * @summary Close Access Request
		         * @param {CloseAccessRequestBeta} closeAccessRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        closeAccessRequest: function (closeAccessRequestBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.closeAccessRequest(closeAccessRequestBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This submits the access request into IdentityNow, where it will follow any IdentityNow approval processes.  Access requests are processed asynchronously by IdentityNow.  A success response from this endpoint means the request has been submitted to IDN and is queued for processing.  Because this endpoint is asynchronous, it will not return an error if you submit duplicate access requests in quick succession, or you submit an access request for access that is already in progress, approved, or rejected. It is best practice to check for any existing access requests that reference the same access items before submitting a new access request.  This can be accomplished by using the [access request status](https://developer.sailpoint.com/idn/api/v3/list-access-request-status) or the [pending access request approvals](https://developer.sailpoint.com/idn/api/v3/list-pending-approvals) endpoints.  You can also use the [search API](https://developer.sailpoint.com/idn/api/v3/search) to check the existing access items that an identity has before submitting an access request to ensure you are not requesting access that is already granted.  There are two types of access request:  __GRANT_ACCESS__ * Can be requested for multiple identities in a single request. * Supports self request and request on behalf of other users. Refer to the [Get Access Request Configuration](https://developer.sailpoint.com/idn/api/v3/get-access-request-config) endpoint for request configuration options.   * Allows any authenticated token (except API) to call this endpoint to request to grant access to themselves. Depending on the configuration, a user can request access for others. * Roles, access profiles and entitlements can be requested. * While requesting entitlements, maximum of 25 entitlements and 10 recipients are allowed in a request.   __REVOKE_ACCESS__ * Can only be requested for a single identity at a time. * You cannot use an access request to revoke access from an identity if that access has been granted by role membership or by birthright provisioning.  * Does not support self request. Only manager can request to revoke access for their directly managed employees. * If a `removeDate` is specified, then the access will be removed on that date and time only for roles and access profiles. Entitlements are currently unsupported for `removeDate`. * Roles, access profiles, and entitlements can be requested for revocation. * Revoke requests for entitlements are limited to 1 entitlement per access request currently. * [Roles, Access Profiles] You can specify a `removeDate` if the access doesn\'t already have a sunset date. The `removeDate` must be a future date, in the UTC timezone.  * Allows a manager to request to revoke access for direct employees. A token with ORG_ADMIN authority can also request to revoke access from anyone.  >**Note:** There is no indication to the approver in the IdentityNow UI that the approval request is for a revoke action. Take this into consideration when calling this API.  A token with API authority cannot be used to call this endpoint.
		         * @summary Submit an Access Request
		         * @param {AccessRequestBeta} accessRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createAccessRequest: function (accessRequestBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.createAccessRequest(accessRequestBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This endpoint returns the current access-request configuration.
		         * @summary Get Access Request Configuration
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getAccessRequestConfig: function (axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getAccessRequestConfig(axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * The Access Request Status API returns a list of access request statuses based on the specified query parameters. Any token with any authority can request their own status. A token with ORG_ADMIN authority is required to call this API to get a list of statuses for other users.
		         * @summary Access Request Status
		         * @param {string} [requestedFor] Filter the results by the identity for which the requests were made. *me* indicates the current user. Mutually exclusive with *regarding-identity*.
		         * @param {string} [requestedBy] Filter the results by the identity that made the requests. *me* indicates the current user. Mutually exclusive with *regarding-identity*.
		         * @param {string} [regardingIdentity] Filter the results by the specified identity which is either the requester or target of the requests. *me* indicates the current user. Mutually exclusive with *requested-for* and *requested-by*.
		         * @param {string} [assignedTo] Filter the results by the specified identity which is the owner of the Identity Request Work Item. *me* indicates the current user.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.
		         * @param {number} [limit] Max number of results to return.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. Defaults to 0 if not specified.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **accountActivityItemId**: *eq, in, ge, gt, le, lt, ne, isnull, sw*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **created, modified, accountActivityItemId, name**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listAccessRequestStatus: function (requestedFor, requestedBy, regardingIdentity, assignedTo, count, limit, offset, filters, sorters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listAccessRequestStatus(requestedFor, requestedBy, regardingIdentity, assignedTo, count, limit, offset, filters, sorters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This endpoint replaces the current access-request configuration. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Update Access Request Configuration
		         * @param {AccessRequestConfigBeta} accessRequestConfigBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        setAccessRequestConfig: function (accessRequestConfigBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.setAccessRequestConfig(accessRequestConfigBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.AccessRequestsBetaApiFp = AccessRequestsBetaApiFp;
		/**
		 * AccessRequestsBetaApi - factory interface
		 * @export
		 */
		var AccessRequestsBetaApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.AccessRequestsBetaApiFp)(configuration);
		    return {
		        /**
		         * This API endpoint cancels a pending access request. An access request can be cancelled only if it has not passed the approval step. Any token with ORG_ADMIN authority or token of the user who originally requested the access request is required to cancel it.
		         * @summary Cancel Access Request
		         * @param {CancelAccessRequestBeta} cancelAccessRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        cancelAccessRequest: function (cancelAccessRequestBeta, axiosOptions) {
		            return localVarFp.cancelAccessRequest(cancelAccessRequestBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This endpoint closes access requests that are stuck in a pending state. It can be used throughout a request\'s lifecycle even after the approval state, unlike the [Cancel Access Request endpoint](https://developer.sailpoint.com/idn/api/v3/cancel-access-request/). A token with ORG_ADMIN authority is required.  To find pending access requests with the UI, navigate to Search and use this query: status: Pending AND \"Access Request\". Use the Column Chooser to select \'Tracking Number\', and use the \'Download\' button to export a CSV containing the tracking numbers.  To find pending access requests with the API, use the [List Account Activities endpoint](https://developer.sailpoint.com/idn/api/v3/list-account-activities/).  Input the IDs from either source.  To track the status of endpoint requests, navigate to Search and use this query: name:\"Close Identity Requests\". Search will include \"Close Identity Requests Started\" audits when requests are initiated and \"Close Identity Requests Completed\" audits when requests are completed. The completion audit will list the identity request IDs that finished in error.  This API triggers the [Provisioning Completed event trigger](https://developer.sailpoint.com/idn/docs/event-triggers/triggers/provisioning-completed/) for each access request that is closed.
		         * @summary Close Access Request
		         * @param {CloseAccessRequestBeta} closeAccessRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        closeAccessRequest: function (closeAccessRequestBeta, axiosOptions) {
		            return localVarFp.closeAccessRequest(closeAccessRequestBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This submits the access request into IdentityNow, where it will follow any IdentityNow approval processes.  Access requests are processed asynchronously by IdentityNow.  A success response from this endpoint means the request has been submitted to IDN and is queued for processing.  Because this endpoint is asynchronous, it will not return an error if you submit duplicate access requests in quick succession, or you submit an access request for access that is already in progress, approved, or rejected. It is best practice to check for any existing access requests that reference the same access items before submitting a new access request.  This can be accomplished by using the [access request status](https://developer.sailpoint.com/idn/api/v3/list-access-request-status) or the [pending access request approvals](https://developer.sailpoint.com/idn/api/v3/list-pending-approvals) endpoints.  You can also use the [search API](https://developer.sailpoint.com/idn/api/v3/search) to check the existing access items that an identity has before submitting an access request to ensure you are not requesting access that is already granted.  There are two types of access request:  __GRANT_ACCESS__ * Can be requested for multiple identities in a single request. * Supports self request and request on behalf of other users. Refer to the [Get Access Request Configuration](https://developer.sailpoint.com/idn/api/v3/get-access-request-config) endpoint for request configuration options.   * Allows any authenticated token (except API) to call this endpoint to request to grant access to themselves. Depending on the configuration, a user can request access for others. * Roles, access profiles and entitlements can be requested. * While requesting entitlements, maximum of 25 entitlements and 10 recipients are allowed in a request.   __REVOKE_ACCESS__ * Can only be requested for a single identity at a time. * You cannot use an access request to revoke access from an identity if that access has been granted by role membership or by birthright provisioning.  * Does not support self request. Only manager can request to revoke access for their directly managed employees. * If a `removeDate` is specified, then the access will be removed on that date and time only for roles and access profiles. Entitlements are currently unsupported for `removeDate`. * Roles, access profiles, and entitlements can be requested for revocation. * Revoke requests for entitlements are limited to 1 entitlement per access request currently. * [Roles, Access Profiles] You can specify a `removeDate` if the access doesn\'t already have a sunset date. The `removeDate` must be a future date, in the UTC timezone.  * Allows a manager to request to revoke access for direct employees. A token with ORG_ADMIN authority can also request to revoke access from anyone.  >**Note:** There is no indication to the approver in the IdentityNow UI that the approval request is for a revoke action. Take this into consideration when calling this API.  A token with API authority cannot be used to call this endpoint.
		         * @summary Submit an Access Request
		         * @param {AccessRequestBeta} accessRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createAccessRequest: function (accessRequestBeta, axiosOptions) {
		            return localVarFp.createAccessRequest(accessRequestBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This endpoint returns the current access-request configuration.
		         * @summary Get Access Request Configuration
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getAccessRequestConfig: function (axiosOptions) {
		            return localVarFp.getAccessRequestConfig(axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * The Access Request Status API returns a list of access request statuses based on the specified query parameters. Any token with any authority can request their own status. A token with ORG_ADMIN authority is required to call this API to get a list of statuses for other users.
		         * @summary Access Request Status
		         * @param {string} [requestedFor] Filter the results by the identity for which the requests were made. *me* indicates the current user. Mutually exclusive with *regarding-identity*.
		         * @param {string} [requestedBy] Filter the results by the identity that made the requests. *me* indicates the current user. Mutually exclusive with *regarding-identity*.
		         * @param {string} [regardingIdentity] Filter the results by the specified identity which is either the requester or target of the requests. *me* indicates the current user. Mutually exclusive with *requested-for* and *requested-by*.
		         * @param {string} [assignedTo] Filter the results by the specified identity which is the owner of the Identity Request Work Item. *me* indicates the current user.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.
		         * @param {number} [limit] Max number of results to return.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. Defaults to 0 if not specified.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **accountActivityItemId**: *eq, in, ge, gt, le, lt, ne, isnull, sw*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **created, modified, accountActivityItemId, name**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listAccessRequestStatus: function (requestedFor, requestedBy, regardingIdentity, assignedTo, count, limit, offset, filters, sorters, axiosOptions) {
		            return localVarFp.listAccessRequestStatus(requestedFor, requestedBy, regardingIdentity, assignedTo, count, limit, offset, filters, sorters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This endpoint replaces the current access-request configuration. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Update Access Request Configuration
		         * @param {AccessRequestConfigBeta} accessRequestConfigBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        setAccessRequestConfig: function (accessRequestConfigBeta, axiosOptions) {
		            return localVarFp.setAccessRequestConfig(accessRequestConfigBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.AccessRequestsBetaApiFactory = AccessRequestsBetaApiFactory;
		/**
		 * AccessRequestsBetaApi - object-oriented interface
		 * @export
		 * @class AccessRequestsBetaApi
		 * @extends {BaseAPI}
		 */
		var AccessRequestsBetaApi = /** @class */ (function (_super) {
		    __extends(AccessRequestsBetaApi, _super);
		    function AccessRequestsBetaApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * This API endpoint cancels a pending access request. An access request can be cancelled only if it has not passed the approval step. Any token with ORG_ADMIN authority or token of the user who originally requested the access request is required to cancel it.
		     * @summary Cancel Access Request
		     * @param {AccessRequestsBetaApiCancelAccessRequestRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof AccessRequestsBetaApi
		     */
		    AccessRequestsBetaApi.prototype.cancelAccessRequest = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.AccessRequestsBetaApiFp)(this.configuration).cancelAccessRequest(requestParameters.cancelAccessRequestBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This endpoint closes access requests that are stuck in a pending state. It can be used throughout a request\'s lifecycle even after the approval state, unlike the [Cancel Access Request endpoint](https://developer.sailpoint.com/idn/api/v3/cancel-access-request/). A token with ORG_ADMIN authority is required.  To find pending access requests with the UI, navigate to Search and use this query: status: Pending AND \"Access Request\". Use the Column Chooser to select \'Tracking Number\', and use the \'Download\' button to export a CSV containing the tracking numbers.  To find pending access requests with the API, use the [List Account Activities endpoint](https://developer.sailpoint.com/idn/api/v3/list-account-activities/).  Input the IDs from either source.  To track the status of endpoint requests, navigate to Search and use this query: name:\"Close Identity Requests\". Search will include \"Close Identity Requests Started\" audits when requests are initiated and \"Close Identity Requests Completed\" audits when requests are completed. The completion audit will list the identity request IDs that finished in error.  This API triggers the [Provisioning Completed event trigger](https://developer.sailpoint.com/idn/docs/event-triggers/triggers/provisioning-completed/) for each access request that is closed.
		     * @summary Close Access Request
		     * @param {AccessRequestsBetaApiCloseAccessRequestRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof AccessRequestsBetaApi
		     */
		    AccessRequestsBetaApi.prototype.closeAccessRequest = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.AccessRequestsBetaApiFp)(this.configuration).closeAccessRequest(requestParameters.closeAccessRequestBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This submits the access request into IdentityNow, where it will follow any IdentityNow approval processes.  Access requests are processed asynchronously by IdentityNow.  A success response from this endpoint means the request has been submitted to IDN and is queued for processing.  Because this endpoint is asynchronous, it will not return an error if you submit duplicate access requests in quick succession, or you submit an access request for access that is already in progress, approved, or rejected. It is best practice to check for any existing access requests that reference the same access items before submitting a new access request.  This can be accomplished by using the [access request status](https://developer.sailpoint.com/idn/api/v3/list-access-request-status) or the [pending access request approvals](https://developer.sailpoint.com/idn/api/v3/list-pending-approvals) endpoints.  You can also use the [search API](https://developer.sailpoint.com/idn/api/v3/search) to check the existing access items that an identity has before submitting an access request to ensure you are not requesting access that is already granted.  There are two types of access request:  __GRANT_ACCESS__ * Can be requested for multiple identities in a single request. * Supports self request and request on behalf of other users. Refer to the [Get Access Request Configuration](https://developer.sailpoint.com/idn/api/v3/get-access-request-config) endpoint for request configuration options.   * Allows any authenticated token (except API) to call this endpoint to request to grant access to themselves. Depending on the configuration, a user can request access for others. * Roles, access profiles and entitlements can be requested. * While requesting entitlements, maximum of 25 entitlements and 10 recipients are allowed in a request.   __REVOKE_ACCESS__ * Can only be requested for a single identity at a time. * You cannot use an access request to revoke access from an identity if that access has been granted by role membership or by birthright provisioning.  * Does not support self request. Only manager can request to revoke access for their directly managed employees. * If a `removeDate` is specified, then the access will be removed on that date and time only for roles and access profiles. Entitlements are currently unsupported for `removeDate`. * Roles, access profiles, and entitlements can be requested for revocation. * Revoke requests for entitlements are limited to 1 entitlement per access request currently. * [Roles, Access Profiles] You can specify a `removeDate` if the access doesn\'t already have a sunset date. The `removeDate` must be a future date, in the UTC timezone.  * Allows a manager to request to revoke access for direct employees. A token with ORG_ADMIN authority can also request to revoke access from anyone.  >**Note:** There is no indication to the approver in the IdentityNow UI that the approval request is for a revoke action. Take this into consideration when calling this API.  A token with API authority cannot be used to call this endpoint.
		     * @summary Submit an Access Request
		     * @param {AccessRequestsBetaApiCreateAccessRequestRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof AccessRequestsBetaApi
		     */
		    AccessRequestsBetaApi.prototype.createAccessRequest = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.AccessRequestsBetaApiFp)(this.configuration).createAccessRequest(requestParameters.accessRequestBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This endpoint returns the current access-request configuration.
		     * @summary Get Access Request Configuration
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof AccessRequestsBetaApi
		     */
		    AccessRequestsBetaApi.prototype.getAccessRequestConfig = function (axiosOptions) {
		        var _this = this;
		        return (0, exports.AccessRequestsBetaApiFp)(this.configuration).getAccessRequestConfig(axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * The Access Request Status API returns a list of access request statuses based on the specified query parameters. Any token with any authority can request their own status. A token with ORG_ADMIN authority is required to call this API to get a list of statuses for other users.
		     * @summary Access Request Status
		     * @param {AccessRequestsBetaApiListAccessRequestStatusRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof AccessRequestsBetaApi
		     */
		    AccessRequestsBetaApi.prototype.listAccessRequestStatus = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.AccessRequestsBetaApiFp)(this.configuration).listAccessRequestStatus(requestParameters.requestedFor, requestParameters.requestedBy, requestParameters.regardingIdentity, requestParameters.assignedTo, requestParameters.count, requestParameters.limit, requestParameters.offset, requestParameters.filters, requestParameters.sorters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This endpoint replaces the current access-request configuration. A token with ORG_ADMIN authority is required to call this API.
		     * @summary Update Access Request Configuration
		     * @param {AccessRequestsBetaApiSetAccessRequestConfigRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof AccessRequestsBetaApi
		     */
		    AccessRequestsBetaApi.prototype.setAccessRequestConfig = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.AccessRequestsBetaApiFp)(this.configuration).setAccessRequestConfig(requestParameters.accessRequestConfigBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return AccessRequestsBetaApi;
		}(base_1.BaseAPI));
		exports.AccessRequestsBetaApi = AccessRequestsBetaApi;
		/**
		 * AccountActivitiesBetaApi - axios parameter creator
		 * @export
		 */
		var AccountActivitiesBetaApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * This gets a single account activity by its id.
		         * @summary Get Account Activity
		         * @param {string} id The account activity id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getAccountActivity: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getAccountActivity', 'id', id);
		                            localVarPath = "/account-activities/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets a collection of account activities that satisfy the given query parameters.
		         * @summary List Account Activities
		         * @param {string} [requestedFor] The identity that the activity was requested for. *me* indicates the current user. Mutually exclusive with *regarding-identity*.
		         * @param {string} [requestedBy] The identity that requested the activity. *me* indicates the current user. Mutually exclusive with *regarding-identity*.
		         * @param {string} [regardingIdentity] The specified identity will be either the requester or target of the account activity. *me* indicates the current user. Mutually exclusive with *requested-for* and *requested-by*.
		         * @param {string} [type] The type of account activity.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **type**: *eq, in, ge, gt, le, lt, ne, isnull, sw*  **created**: *gt, lt, ge, le, eq, in, ne, isnull, sw*  **modified**: *gt, lt, ge, le, eq, in, ne, isnull, sw*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **type, created, modified**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listAccountActivities: function (requestedFor, requestedBy, regardingIdentity, type, limit, offset, count, filters, sorters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/account-activities";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (requestedFor !== undefined) {
		                                localVarQueryParameter['requested-for'] = requestedFor;
		                            }
		                            if (requestedBy !== undefined) {
		                                localVarQueryParameter['requested-by'] = requestedBy;
		                            }
		                            if (regardingIdentity !== undefined) {
		                                localVarQueryParameter['regarding-identity'] = regardingIdentity;
		                            }
		                            if (type !== undefined) {
		                                localVarQueryParameter['type'] = type;
		                            }
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.AccountActivitiesBetaApiAxiosParamCreator = AccountActivitiesBetaApiAxiosParamCreator;
		/**
		 * AccountActivitiesBetaApi - functional programming interface
		 * @export
		 */
		var AccountActivitiesBetaApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.AccountActivitiesBetaApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * This gets a single account activity by its id.
		         * @summary Get Account Activity
		         * @param {string} id The account activity id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getAccountActivity: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getAccountActivity(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets a collection of account activities that satisfy the given query parameters.
		         * @summary List Account Activities
		         * @param {string} [requestedFor] The identity that the activity was requested for. *me* indicates the current user. Mutually exclusive with *regarding-identity*.
		         * @param {string} [requestedBy] The identity that requested the activity. *me* indicates the current user. Mutually exclusive with *regarding-identity*.
		         * @param {string} [regardingIdentity] The specified identity will be either the requester or target of the account activity. *me* indicates the current user. Mutually exclusive with *requested-for* and *requested-by*.
		         * @param {string} [type] The type of account activity.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **type**: *eq, in, ge, gt, le, lt, ne, isnull, sw*  **created**: *gt, lt, ge, le, eq, in, ne, isnull, sw*  **modified**: *gt, lt, ge, le, eq, in, ne, isnull, sw*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **type, created, modified**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listAccountActivities: function (requestedFor, requestedBy, regardingIdentity, type, limit, offset, count, filters, sorters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listAccountActivities(requestedFor, requestedBy, regardingIdentity, type, limit, offset, count, filters, sorters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.AccountActivitiesBetaApiFp = AccountActivitiesBetaApiFp;
		/**
		 * AccountActivitiesBetaApi - factory interface
		 * @export
		 */
		var AccountActivitiesBetaApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.AccountActivitiesBetaApiFp)(configuration);
		    return {
		        /**
		         * This gets a single account activity by its id.
		         * @summary Get Account Activity
		         * @param {string} id The account activity id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getAccountActivity: function (id, axiosOptions) {
		            return localVarFp.getAccountActivity(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This gets a collection of account activities that satisfy the given query parameters.
		         * @summary List Account Activities
		         * @param {string} [requestedFor] The identity that the activity was requested for. *me* indicates the current user. Mutually exclusive with *regarding-identity*.
		         * @param {string} [requestedBy] The identity that requested the activity. *me* indicates the current user. Mutually exclusive with *regarding-identity*.
		         * @param {string} [regardingIdentity] The specified identity will be either the requester or target of the account activity. *me* indicates the current user. Mutually exclusive with *requested-for* and *requested-by*.
		         * @param {string} [type] The type of account activity.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **type**: *eq, in, ge, gt, le, lt, ne, isnull, sw*  **created**: *gt, lt, ge, le, eq, in, ne, isnull, sw*  **modified**: *gt, lt, ge, le, eq, in, ne, isnull, sw*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **type, created, modified**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listAccountActivities: function (requestedFor, requestedBy, regardingIdentity, type, limit, offset, count, filters, sorters, axiosOptions) {
		            return localVarFp.listAccountActivities(requestedFor, requestedBy, regardingIdentity, type, limit, offset, count, filters, sorters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.AccountActivitiesBetaApiFactory = AccountActivitiesBetaApiFactory;
		/**
		 * AccountActivitiesBetaApi - object-oriented interface
		 * @export
		 * @class AccountActivitiesBetaApi
		 * @extends {BaseAPI}
		 */
		var AccountActivitiesBetaApi = /** @class */ (function (_super) {
		    __extends(AccountActivitiesBetaApi, _super);
		    function AccountActivitiesBetaApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * This gets a single account activity by its id.
		     * @summary Get Account Activity
		     * @param {AccountActivitiesBetaApiGetAccountActivityRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof AccountActivitiesBetaApi
		     */
		    AccountActivitiesBetaApi.prototype.getAccountActivity = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.AccountActivitiesBetaApiFp)(this.configuration).getAccountActivity(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This gets a collection of account activities that satisfy the given query parameters.
		     * @summary List Account Activities
		     * @param {AccountActivitiesBetaApiListAccountActivitiesRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof AccountActivitiesBetaApi
		     */
		    AccountActivitiesBetaApi.prototype.listAccountActivities = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.AccountActivitiesBetaApiFp)(this.configuration).listAccountActivities(requestParameters.requestedFor, requestParameters.requestedBy, requestParameters.regardingIdentity, requestParameters.type, requestParameters.limit, requestParameters.offset, requestParameters.count, requestParameters.filters, requestParameters.sorters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return AccountActivitiesBetaApi;
		}(base_1.BaseAPI));
		exports.AccountActivitiesBetaApi = AccountActivitiesBetaApi;
		/**
		 * AccountAggregationsBetaApi - axios parameter creator
		 * @export
		 */
		var AccountAggregationsBetaApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * This API returns the status of an *in-progress* account aggregation, along with the total number of **NEW**, **CHANGED** and **DELETED** accounts found since the previous aggregation, and the number of those accounts that have been processed so far.  Accounts that have not changed since the previous aggregation are not included in **totalAccounts** and **processedAccounts** counts returned by this API. This is distinct from **Accounts Scanned** shown in the Aggregation UI, which indicates total accounts scanned regardless of whether they changed or not.  Since this endpoint reports on the status of an *in-progress* account aggregation, totalAccounts and processedAccounts may change between calls to this endpoint.  *Only available up to an hour after the aggregation completes. May respond with *404 Not Found* after that.*  A token with ORG_ADMIN, SOURCE_ADMIN, SOURCE_SUBADMIN or DASHBOARD authority is required to call this API.
		         * @summary In-progress Account Aggregation status
		         * @param {string} id The account aggregation id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getAccountAggregationStatus: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getAccountAggregationStatus', 'id', id);
		                            localVarPath = "/account-aggregations/{id}/status"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.AccountAggregationsBetaApiAxiosParamCreator = AccountAggregationsBetaApiAxiosParamCreator;
		/**
		 * AccountAggregationsBetaApi - functional programming interface
		 * @export
		 */
		var AccountAggregationsBetaApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.AccountAggregationsBetaApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * This API returns the status of an *in-progress* account aggregation, along with the total number of **NEW**, **CHANGED** and **DELETED** accounts found since the previous aggregation, and the number of those accounts that have been processed so far.  Accounts that have not changed since the previous aggregation are not included in **totalAccounts** and **processedAccounts** counts returned by this API. This is distinct from **Accounts Scanned** shown in the Aggregation UI, which indicates total accounts scanned regardless of whether they changed or not.  Since this endpoint reports on the status of an *in-progress* account aggregation, totalAccounts and processedAccounts may change between calls to this endpoint.  *Only available up to an hour after the aggregation completes. May respond with *404 Not Found* after that.*  A token with ORG_ADMIN, SOURCE_ADMIN, SOURCE_SUBADMIN or DASHBOARD authority is required to call this API.
		         * @summary In-progress Account Aggregation status
		         * @param {string} id The account aggregation id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getAccountAggregationStatus: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getAccountAggregationStatus(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.AccountAggregationsBetaApiFp = AccountAggregationsBetaApiFp;
		/**
		 * AccountAggregationsBetaApi - factory interface
		 * @export
		 */
		var AccountAggregationsBetaApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.AccountAggregationsBetaApiFp)(configuration);
		    return {
		        /**
		         * This API returns the status of an *in-progress* account aggregation, along with the total number of **NEW**, **CHANGED** and **DELETED** accounts found since the previous aggregation, and the number of those accounts that have been processed so far.  Accounts that have not changed since the previous aggregation are not included in **totalAccounts** and **processedAccounts** counts returned by this API. This is distinct from **Accounts Scanned** shown in the Aggregation UI, which indicates total accounts scanned regardless of whether they changed or not.  Since this endpoint reports on the status of an *in-progress* account aggregation, totalAccounts and processedAccounts may change between calls to this endpoint.  *Only available up to an hour after the aggregation completes. May respond with *404 Not Found* after that.*  A token with ORG_ADMIN, SOURCE_ADMIN, SOURCE_SUBADMIN or DASHBOARD authority is required to call this API.
		         * @summary In-progress Account Aggregation status
		         * @param {string} id The account aggregation id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getAccountAggregationStatus: function (id, axiosOptions) {
		            return localVarFp.getAccountAggregationStatus(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.AccountAggregationsBetaApiFactory = AccountAggregationsBetaApiFactory;
		/**
		 * AccountAggregationsBetaApi - object-oriented interface
		 * @export
		 * @class AccountAggregationsBetaApi
		 * @extends {BaseAPI}
		 */
		var AccountAggregationsBetaApi = /** @class */ (function (_super) {
		    __extends(AccountAggregationsBetaApi, _super);
		    function AccountAggregationsBetaApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * This API returns the status of an *in-progress* account aggregation, along with the total number of **NEW**, **CHANGED** and **DELETED** accounts found since the previous aggregation, and the number of those accounts that have been processed so far.  Accounts that have not changed since the previous aggregation are not included in **totalAccounts** and **processedAccounts** counts returned by this API. This is distinct from **Accounts Scanned** shown in the Aggregation UI, which indicates total accounts scanned regardless of whether they changed or not.  Since this endpoint reports on the status of an *in-progress* account aggregation, totalAccounts and processedAccounts may change between calls to this endpoint.  *Only available up to an hour after the aggregation completes. May respond with *404 Not Found* after that.*  A token with ORG_ADMIN, SOURCE_ADMIN, SOURCE_SUBADMIN or DASHBOARD authority is required to call this API.
		     * @summary In-progress Account Aggregation status
		     * @param {AccountAggregationsBetaApiGetAccountAggregationStatusRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof AccountAggregationsBetaApi
		     */
		    AccountAggregationsBetaApi.prototype.getAccountAggregationStatus = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.AccountAggregationsBetaApiFp)(this.configuration).getAccountAggregationStatus(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return AccountAggregationsBetaApi;
		}(base_1.BaseAPI));
		exports.AccountAggregationsBetaApi = AccountAggregationsBetaApi;
		/**
		 * AccountUsagesBetaApi - axios parameter creator
		 * @export
		 */
		var AccountUsagesBetaApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * This API returns a summary of account usage insights for past 12 months.
		         * @summary Returns account usage insights
		         * @param {string} accountId ID of IDN account
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **date**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getUsagesByAccountId: function (accountId, limit, offset, count, sorters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'accountId' is not null or undefined
		                            (0, common_1.assertParamExists)('getUsagesByAccountId', 'accountId', accountId);
		                            localVarPath = "/account-usages/{accountId}/summaries"
		                                .replace("{".concat("accountId", "}"), encodeURIComponent(String(accountId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.AccountUsagesBetaApiAxiosParamCreator = AccountUsagesBetaApiAxiosParamCreator;
		/**
		 * AccountUsagesBetaApi - functional programming interface
		 * @export
		 */
		var AccountUsagesBetaApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.AccountUsagesBetaApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * This API returns a summary of account usage insights for past 12 months.
		         * @summary Returns account usage insights
		         * @param {string} accountId ID of IDN account
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **date**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getUsagesByAccountId: function (accountId, limit, offset, count, sorters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getUsagesByAccountId(accountId, limit, offset, count, sorters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.AccountUsagesBetaApiFp = AccountUsagesBetaApiFp;
		/**
		 * AccountUsagesBetaApi - factory interface
		 * @export
		 */
		var AccountUsagesBetaApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.AccountUsagesBetaApiFp)(configuration);
		    return {
		        /**
		         * This API returns a summary of account usage insights for past 12 months.
		         * @summary Returns account usage insights
		         * @param {string} accountId ID of IDN account
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **date**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getUsagesByAccountId: function (accountId, limit, offset, count, sorters, axiosOptions) {
		            return localVarFp.getUsagesByAccountId(accountId, limit, offset, count, sorters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.AccountUsagesBetaApiFactory = AccountUsagesBetaApiFactory;
		/**
		 * AccountUsagesBetaApi - object-oriented interface
		 * @export
		 * @class AccountUsagesBetaApi
		 * @extends {BaseAPI}
		 */
		var AccountUsagesBetaApi = /** @class */ (function (_super) {
		    __extends(AccountUsagesBetaApi, _super);
		    function AccountUsagesBetaApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * This API returns a summary of account usage insights for past 12 months.
		     * @summary Returns account usage insights
		     * @param {AccountUsagesBetaApiGetUsagesByAccountIdRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof AccountUsagesBetaApi
		     */
		    AccountUsagesBetaApi.prototype.getUsagesByAccountId = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.AccountUsagesBetaApiFp)(this.configuration).getUsagesByAccountId(requestParameters.accountId, requestParameters.limit, requestParameters.offset, requestParameters.count, requestParameters.sorters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return AccountUsagesBetaApi;
		}(base_1.BaseAPI));
		exports.AccountUsagesBetaApi = AccountUsagesBetaApi;
		/**
		 * AccountsBetaApi - axios parameter creator
		 * @export
		 */
		var AccountsBetaApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * This API submits an account creation task and returns the task ID.   The `sourceId` where this account will be created must be included in the `attributes` object. >**Note: This API only supports account creation for file based sources.** A token with ORG_ADMIN authority is required to call this API.
		         * @summary Create Account
		         * @param {AccountAttributesCreateBeta} accountAttributesCreateBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createAccount: function (accountAttributesCreateBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'accountAttributesCreateBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('createAccount', 'accountAttributesCreateBeta', accountAttributesCreateBeta);
		                            localVarPath = "/accounts";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(accountAttributesCreateBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Use this API to delete an account.  This endpoint submits an account delete task and returns the task ID.  This endpoint only deletes the account from IdentityNow, not the source itself, which can result in the account\'s returning with the next aggregation between the source and IdentityNow.  To avoid this scenario, it is recommended that you [disable accounts](https://developer.sailpoint.com/idn/api/v3/disable-account) rather than delete them. This will also allow you to reenable the accounts in the future.  A token with ORG_ADMIN authority is required to call this API. >**NOTE:** You can only delete accounts from sources of the \"DelimitedFile\" type.**
		         * @summary Delete Account
		         * @param {string} id Account ID.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteAccount: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('deleteAccount', 'id', id);
		                            localVarPath = "/accounts/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'DELETE' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API submits a task to disable the account and returns the task ID.   A token with ORG_ADMIN authority is required to call this API.
		         * @summary Disable Account
		         * @param {string} id The account id
		         * @param {AccountToggleRequestBeta} accountToggleRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        disableAccount: function (id, accountToggleRequestBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('disableAccount', 'id', id);
		                            // verify required parameter 'accountToggleRequestBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('disableAccount', 'accountToggleRequestBeta', accountToggleRequestBeta);
		                            localVarPath = "/accounts/{id}/disable"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(accountToggleRequestBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API submits a task to disable IDN account for a single identity.
		         * @summary Disable IDN Account for Identity
		         * @param {string} id The identity id.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        disableAccountForIdentity: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('disableAccountForIdentity', 'id', id);
		                            localVarPath = "/identities-accounts/{id}/disable"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API submits tasks to disable IDN account for each identity provided in the request body.
		         * @summary Disable IDN Accounts for Identities
		         * @param {IdentitiesAccountsBulkRequestBeta} identitiesAccountsBulkRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        disableAccountsForIdentities: function (identitiesAccountsBulkRequestBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'identitiesAccountsBulkRequestBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('disableAccountsForIdentities', 'identitiesAccountsBulkRequestBeta', identitiesAccountsBulkRequestBeta);
		                            localVarPath = "/identities-accounts/disable";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(identitiesAccountsBulkRequestBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API submits a task to enable account and returns the task ID.   A token with ORG_ADMIN authority is required to call this API.
		         * @summary Enable Account
		         * @param {string} id The account id
		         * @param {AccountToggleRequestBeta} accountToggleRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        enableAccount: function (id, accountToggleRequestBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('enableAccount', 'id', id);
		                            // verify required parameter 'accountToggleRequestBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('enableAccount', 'accountToggleRequestBeta', accountToggleRequestBeta);
		                            localVarPath = "/accounts/{id}/enable"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(accountToggleRequestBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API submits a task to enable IDN account for a single identity.
		         * @summary Enable IDN Account for Identity
		         * @param {string} id The identity id.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        enableAccountForIdentity: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('enableAccountForIdentity', 'id', id);
		                            localVarPath = "/identities-accounts/{id}/enable"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API submits tasks to enable IDN account for each identity provided in the request body.
		         * @summary Enable IDN Accounts for Identities
		         * @param {IdentitiesAccountsBulkRequestBeta} identitiesAccountsBulkRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        enableAccountsForIdentities: function (identitiesAccountsBulkRequestBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'identitiesAccountsBulkRequestBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('enableAccountsForIdentities', 'identitiesAccountsBulkRequestBeta', identitiesAccountsBulkRequestBeta);
		                            localVarPath = "/identities-accounts/enable";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(identitiesAccountsBulkRequestBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Use this API to return the details for a single account by its ID.   A token with ORG_ADMIN authority is required to call this API.
		         * @summary Account Details
		         * @param {string} id Account ID.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getAccount: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getAccount', 'id', id);
		                            localVarPath = "/accounts/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns entitlements of the account.   A token with ORG_ADMIN authority is required to call this API.
		         * @summary Account Entitlements
		         * @param {string} id The account id
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getAccountEntitlements: function (id, offset, limit, count, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getAccountEntitlements', 'id', id);
		                            localVarPath = "/accounts/{id}/entitlements"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This returns a list of accounts.   A token with ORG_ADMIN authority is required to call this API.
		         * @summary Accounts List
		         * @param {'SLIM' | 'FULL'} [detailLevel] Determines whether Slim, or increased level of detail is provided for each account in the returned list. FULL is the default behavior.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **identityId**: *eq*  **name**: *eq, in*  **nativeIdentity**: *eq, in*  **sourceId**: *eq, in*  **uncorrelated**: *eq*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **id, name, created, modified**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listAccounts: function (detailLevel, limit, offset, count, filters, sorters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/accounts";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (detailLevel !== undefined) {
		                                localVarQueryParameter['detailLevel'] = detailLevel;
		                            }
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Use this API to update an account with a PUT request.  This endpoint submits an account update task and returns the task ID.   A token with ORG_ADMIN authority is required to call this API. >**NOTE: You can only use this PUT endpoint to update accounts from sources of the \"DelimitedFile\" type.**
		         * @summary Update Account
		         * @param {string} id Account ID.
		         * @param {AccountAttributesBeta} accountAttributesBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putAccount: function (id, accountAttributesBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('putAccount', 'id', id);
		                            // verify required parameter 'accountAttributesBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('putAccount', 'accountAttributesBeta', accountAttributesBeta);
		                            localVarPath = "/accounts/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PUT' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(accountAttributesBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API asynchronously reloads the account directly from the connector and performs a one-time aggregation process.   A token with ORG_ADMIN authority is required to call this API.
		         * @summary Reload Account
		         * @param {string} id The account id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        reloadAccount: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('reloadAccount', 'id', id);
		                            localVarPath = "/accounts/{id}/reload"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API submits a task to unlock an account and returns the task ID.   A token with ORG_ADMIN authority is required to call this API.
		         * @summary Unlock Account
		         * @param {string} id The account id
		         * @param {AccountUnlockRequestBeta} accountUnlockRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        unlockAccount: function (id, accountUnlockRequestBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('unlockAccount', 'id', id);
		                            // verify required parameter 'accountUnlockRequestBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('unlockAccount', 'accountUnlockRequestBeta', accountUnlockRequestBeta);
		                            localVarPath = "/accounts/{id}/unlock"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(accountUnlockRequestBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Use this endpoint to update an account with a PATCH request.  The request must provide a JSONPatch payload. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Update Account
		         * @param {string} id Account ID.
		         * @param {Array<object>} requestBody A list of account update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateAccount: function (id, requestBody, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('updateAccount', 'id', id);
		                            // verify required parameter 'requestBody' is not null or undefined
		                            (0, common_1.assertParamExists)('updateAccount', 'requestBody', requestBody);
		                            localVarPath = "/accounts/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PATCH' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json-patch+json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(requestBody, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.AccountsBetaApiAxiosParamCreator = AccountsBetaApiAxiosParamCreator;
		/**
		 * AccountsBetaApi - functional programming interface
		 * @export
		 */
		var AccountsBetaApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.AccountsBetaApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * This API submits an account creation task and returns the task ID.   The `sourceId` where this account will be created must be included in the `attributes` object. >**Note: This API only supports account creation for file based sources.** A token with ORG_ADMIN authority is required to call this API.
		         * @summary Create Account
		         * @param {AccountAttributesCreateBeta} accountAttributesCreateBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createAccount: function (accountAttributesCreateBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.createAccount(accountAttributesCreateBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Use this API to delete an account.  This endpoint submits an account delete task and returns the task ID.  This endpoint only deletes the account from IdentityNow, not the source itself, which can result in the account\'s returning with the next aggregation between the source and IdentityNow.  To avoid this scenario, it is recommended that you [disable accounts](https://developer.sailpoint.com/idn/api/v3/disable-account) rather than delete them. This will also allow you to reenable the accounts in the future.  A token with ORG_ADMIN authority is required to call this API. >**NOTE:** You can only delete accounts from sources of the \"DelimitedFile\" type.**
		         * @summary Delete Account
		         * @param {string} id Account ID.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteAccount: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.deleteAccount(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API submits a task to disable the account and returns the task ID.   A token with ORG_ADMIN authority is required to call this API.
		         * @summary Disable Account
		         * @param {string} id The account id
		         * @param {AccountToggleRequestBeta} accountToggleRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        disableAccount: function (id, accountToggleRequestBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.disableAccount(id, accountToggleRequestBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API submits a task to disable IDN account for a single identity.
		         * @summary Disable IDN Account for Identity
		         * @param {string} id The identity id.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        disableAccountForIdentity: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.disableAccountForIdentity(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API submits tasks to disable IDN account for each identity provided in the request body.
		         * @summary Disable IDN Accounts for Identities
		         * @param {IdentitiesAccountsBulkRequestBeta} identitiesAccountsBulkRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        disableAccountsForIdentities: function (identitiesAccountsBulkRequestBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.disableAccountsForIdentities(identitiesAccountsBulkRequestBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API submits a task to enable account and returns the task ID.   A token with ORG_ADMIN authority is required to call this API.
		         * @summary Enable Account
		         * @param {string} id The account id
		         * @param {AccountToggleRequestBeta} accountToggleRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        enableAccount: function (id, accountToggleRequestBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.enableAccount(id, accountToggleRequestBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API submits a task to enable IDN account for a single identity.
		         * @summary Enable IDN Account for Identity
		         * @param {string} id The identity id.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        enableAccountForIdentity: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.enableAccountForIdentity(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API submits tasks to enable IDN account for each identity provided in the request body.
		         * @summary Enable IDN Accounts for Identities
		         * @param {IdentitiesAccountsBulkRequestBeta} identitiesAccountsBulkRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        enableAccountsForIdentities: function (identitiesAccountsBulkRequestBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.enableAccountsForIdentities(identitiesAccountsBulkRequestBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Use this API to return the details for a single account by its ID.   A token with ORG_ADMIN authority is required to call this API.
		         * @summary Account Details
		         * @param {string} id Account ID.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getAccount: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getAccount(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns entitlements of the account.   A token with ORG_ADMIN authority is required to call this API.
		         * @summary Account Entitlements
		         * @param {string} id The account id
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getAccountEntitlements: function (id, offset, limit, count, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getAccountEntitlements(id, offset, limit, count, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This returns a list of accounts.   A token with ORG_ADMIN authority is required to call this API.
		         * @summary Accounts List
		         * @param {'SLIM' | 'FULL'} [detailLevel] Determines whether Slim, or increased level of detail is provided for each account in the returned list. FULL is the default behavior.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **identityId**: *eq*  **name**: *eq, in*  **nativeIdentity**: *eq, in*  **sourceId**: *eq, in*  **uncorrelated**: *eq*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **id, name, created, modified**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listAccounts: function (detailLevel, limit, offset, count, filters, sorters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listAccounts(detailLevel, limit, offset, count, filters, sorters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Use this API to update an account with a PUT request.  This endpoint submits an account update task and returns the task ID.   A token with ORG_ADMIN authority is required to call this API. >**NOTE: You can only use this PUT endpoint to update accounts from sources of the \"DelimitedFile\" type.**
		         * @summary Update Account
		         * @param {string} id Account ID.
		         * @param {AccountAttributesBeta} accountAttributesBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putAccount: function (id, accountAttributesBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.putAccount(id, accountAttributesBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API asynchronously reloads the account directly from the connector and performs a one-time aggregation process.   A token with ORG_ADMIN authority is required to call this API.
		         * @summary Reload Account
		         * @param {string} id The account id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        reloadAccount: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.reloadAccount(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API submits a task to unlock an account and returns the task ID.   A token with ORG_ADMIN authority is required to call this API.
		         * @summary Unlock Account
		         * @param {string} id The account id
		         * @param {AccountUnlockRequestBeta} accountUnlockRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        unlockAccount: function (id, accountUnlockRequestBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.unlockAccount(id, accountUnlockRequestBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Use this endpoint to update an account with a PATCH request.  The request must provide a JSONPatch payload. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Update Account
		         * @param {string} id Account ID.
		         * @param {Array<object>} requestBody A list of account update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateAccount: function (id, requestBody, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.updateAccount(id, requestBody, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.AccountsBetaApiFp = AccountsBetaApiFp;
		/**
		 * AccountsBetaApi - factory interface
		 * @export
		 */
		var AccountsBetaApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.AccountsBetaApiFp)(configuration);
		    return {
		        /**
		         * This API submits an account creation task and returns the task ID.   The `sourceId` where this account will be created must be included in the `attributes` object. >**Note: This API only supports account creation for file based sources.** A token with ORG_ADMIN authority is required to call this API.
		         * @summary Create Account
		         * @param {AccountAttributesCreateBeta} accountAttributesCreateBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createAccount: function (accountAttributesCreateBeta, axiosOptions) {
		            return localVarFp.createAccount(accountAttributesCreateBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Use this API to delete an account.  This endpoint submits an account delete task and returns the task ID.  This endpoint only deletes the account from IdentityNow, not the source itself, which can result in the account\'s returning with the next aggregation between the source and IdentityNow.  To avoid this scenario, it is recommended that you [disable accounts](https://developer.sailpoint.com/idn/api/v3/disable-account) rather than delete them. This will also allow you to reenable the accounts in the future.  A token with ORG_ADMIN authority is required to call this API. >**NOTE:** You can only delete accounts from sources of the \"DelimitedFile\" type.**
		         * @summary Delete Account
		         * @param {string} id Account ID.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteAccount: function (id, axiosOptions) {
		            return localVarFp.deleteAccount(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API submits a task to disable the account and returns the task ID.   A token with ORG_ADMIN authority is required to call this API.
		         * @summary Disable Account
		         * @param {string} id The account id
		         * @param {AccountToggleRequestBeta} accountToggleRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        disableAccount: function (id, accountToggleRequestBeta, axiosOptions) {
		            return localVarFp.disableAccount(id, accountToggleRequestBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API submits a task to disable IDN account for a single identity.
		         * @summary Disable IDN Account for Identity
		         * @param {string} id The identity id.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        disableAccountForIdentity: function (id, axiosOptions) {
		            return localVarFp.disableAccountForIdentity(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API submits tasks to disable IDN account for each identity provided in the request body.
		         * @summary Disable IDN Accounts for Identities
		         * @param {IdentitiesAccountsBulkRequestBeta} identitiesAccountsBulkRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        disableAccountsForIdentities: function (identitiesAccountsBulkRequestBeta, axiosOptions) {
		            return localVarFp.disableAccountsForIdentities(identitiesAccountsBulkRequestBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API submits a task to enable account and returns the task ID.   A token with ORG_ADMIN authority is required to call this API.
		         * @summary Enable Account
		         * @param {string} id The account id
		         * @param {AccountToggleRequestBeta} accountToggleRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        enableAccount: function (id, accountToggleRequestBeta, axiosOptions) {
		            return localVarFp.enableAccount(id, accountToggleRequestBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API submits a task to enable IDN account for a single identity.
		         * @summary Enable IDN Account for Identity
		         * @param {string} id The identity id.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        enableAccountForIdentity: function (id, axiosOptions) {
		            return localVarFp.enableAccountForIdentity(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API submits tasks to enable IDN account for each identity provided in the request body.
		         * @summary Enable IDN Accounts for Identities
		         * @param {IdentitiesAccountsBulkRequestBeta} identitiesAccountsBulkRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        enableAccountsForIdentities: function (identitiesAccountsBulkRequestBeta, axiosOptions) {
		            return localVarFp.enableAccountsForIdentities(identitiesAccountsBulkRequestBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Use this API to return the details for a single account by its ID.   A token with ORG_ADMIN authority is required to call this API.
		         * @summary Account Details
		         * @param {string} id Account ID.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getAccount: function (id, axiosOptions) {
		            return localVarFp.getAccount(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API returns entitlements of the account.   A token with ORG_ADMIN authority is required to call this API.
		         * @summary Account Entitlements
		         * @param {string} id The account id
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getAccountEntitlements: function (id, offset, limit, count, axiosOptions) {
		            return localVarFp.getAccountEntitlements(id, offset, limit, count, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This returns a list of accounts.   A token with ORG_ADMIN authority is required to call this API.
		         * @summary Accounts List
		         * @param {'SLIM' | 'FULL'} [detailLevel] Determines whether Slim, or increased level of detail is provided for each account in the returned list. FULL is the default behavior.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **identityId**: *eq*  **name**: *eq, in*  **nativeIdentity**: *eq, in*  **sourceId**: *eq, in*  **uncorrelated**: *eq*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **id, name, created, modified**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listAccounts: function (detailLevel, limit, offset, count, filters, sorters, axiosOptions) {
		            return localVarFp.listAccounts(detailLevel, limit, offset, count, filters, sorters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Use this API to update an account with a PUT request.  This endpoint submits an account update task and returns the task ID.   A token with ORG_ADMIN authority is required to call this API. >**NOTE: You can only use this PUT endpoint to update accounts from sources of the \"DelimitedFile\" type.**
		         * @summary Update Account
		         * @param {string} id Account ID.
		         * @param {AccountAttributesBeta} accountAttributesBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putAccount: function (id, accountAttributesBeta, axiosOptions) {
		            return localVarFp.putAccount(id, accountAttributesBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API asynchronously reloads the account directly from the connector and performs a one-time aggregation process.   A token with ORG_ADMIN authority is required to call this API.
		         * @summary Reload Account
		         * @param {string} id The account id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        reloadAccount: function (id, axiosOptions) {
		            return localVarFp.reloadAccount(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API submits a task to unlock an account and returns the task ID.   A token with ORG_ADMIN authority is required to call this API.
		         * @summary Unlock Account
		         * @param {string} id The account id
		         * @param {AccountUnlockRequestBeta} accountUnlockRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        unlockAccount: function (id, accountUnlockRequestBeta, axiosOptions) {
		            return localVarFp.unlockAccount(id, accountUnlockRequestBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Use this endpoint to update an account with a PATCH request.  The request must provide a JSONPatch payload. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Update Account
		         * @param {string} id Account ID.
		         * @param {Array<object>} requestBody A list of account update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateAccount: function (id, requestBody, axiosOptions) {
		            return localVarFp.updateAccount(id, requestBody, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.AccountsBetaApiFactory = AccountsBetaApiFactory;
		/**
		 * AccountsBetaApi - object-oriented interface
		 * @export
		 * @class AccountsBetaApi
		 * @extends {BaseAPI}
		 */
		var AccountsBetaApi = /** @class */ (function (_super) {
		    __extends(AccountsBetaApi, _super);
		    function AccountsBetaApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * This API submits an account creation task and returns the task ID.   The `sourceId` where this account will be created must be included in the `attributes` object. >**Note: This API only supports account creation for file based sources.** A token with ORG_ADMIN authority is required to call this API.
		     * @summary Create Account
		     * @param {AccountsBetaApiCreateAccountRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof AccountsBetaApi
		     */
		    AccountsBetaApi.prototype.createAccount = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.AccountsBetaApiFp)(this.configuration).createAccount(requestParameters.accountAttributesCreateBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Use this API to delete an account.  This endpoint submits an account delete task and returns the task ID.  This endpoint only deletes the account from IdentityNow, not the source itself, which can result in the account\'s returning with the next aggregation between the source and IdentityNow.  To avoid this scenario, it is recommended that you [disable accounts](https://developer.sailpoint.com/idn/api/v3/disable-account) rather than delete them. This will also allow you to reenable the accounts in the future.  A token with ORG_ADMIN authority is required to call this API. >**NOTE:** You can only delete accounts from sources of the \"DelimitedFile\" type.**
		     * @summary Delete Account
		     * @param {AccountsBetaApiDeleteAccountRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof AccountsBetaApi
		     */
		    AccountsBetaApi.prototype.deleteAccount = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.AccountsBetaApiFp)(this.configuration).deleteAccount(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API submits a task to disable the account and returns the task ID.   A token with ORG_ADMIN authority is required to call this API.
		     * @summary Disable Account
		     * @param {AccountsBetaApiDisableAccountRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof AccountsBetaApi
		     */
		    AccountsBetaApi.prototype.disableAccount = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.AccountsBetaApiFp)(this.configuration).disableAccount(requestParameters.id, requestParameters.accountToggleRequestBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API submits a task to disable IDN account for a single identity.
		     * @summary Disable IDN Account for Identity
		     * @param {AccountsBetaApiDisableAccountForIdentityRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof AccountsBetaApi
		     */
		    AccountsBetaApi.prototype.disableAccountForIdentity = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.AccountsBetaApiFp)(this.configuration).disableAccountForIdentity(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API submits tasks to disable IDN account for each identity provided in the request body.
		     * @summary Disable IDN Accounts for Identities
		     * @param {AccountsBetaApiDisableAccountsForIdentitiesRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof AccountsBetaApi
		     */
		    AccountsBetaApi.prototype.disableAccountsForIdentities = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.AccountsBetaApiFp)(this.configuration).disableAccountsForIdentities(requestParameters.identitiesAccountsBulkRequestBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API submits a task to enable account and returns the task ID.   A token with ORG_ADMIN authority is required to call this API.
		     * @summary Enable Account
		     * @param {AccountsBetaApiEnableAccountRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof AccountsBetaApi
		     */
		    AccountsBetaApi.prototype.enableAccount = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.AccountsBetaApiFp)(this.configuration).enableAccount(requestParameters.id, requestParameters.accountToggleRequestBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API submits a task to enable IDN account for a single identity.
		     * @summary Enable IDN Account for Identity
		     * @param {AccountsBetaApiEnableAccountForIdentityRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof AccountsBetaApi
		     */
		    AccountsBetaApi.prototype.enableAccountForIdentity = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.AccountsBetaApiFp)(this.configuration).enableAccountForIdentity(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API submits tasks to enable IDN account for each identity provided in the request body.
		     * @summary Enable IDN Accounts for Identities
		     * @param {AccountsBetaApiEnableAccountsForIdentitiesRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof AccountsBetaApi
		     */
		    AccountsBetaApi.prototype.enableAccountsForIdentities = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.AccountsBetaApiFp)(this.configuration).enableAccountsForIdentities(requestParameters.identitiesAccountsBulkRequestBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Use this API to return the details for a single account by its ID.   A token with ORG_ADMIN authority is required to call this API.
		     * @summary Account Details
		     * @param {AccountsBetaApiGetAccountRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof AccountsBetaApi
		     */
		    AccountsBetaApi.prototype.getAccount = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.AccountsBetaApiFp)(this.configuration).getAccount(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API returns entitlements of the account.   A token with ORG_ADMIN authority is required to call this API.
		     * @summary Account Entitlements
		     * @param {AccountsBetaApiGetAccountEntitlementsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof AccountsBetaApi
		     */
		    AccountsBetaApi.prototype.getAccountEntitlements = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.AccountsBetaApiFp)(this.configuration).getAccountEntitlements(requestParameters.id, requestParameters.offset, requestParameters.limit, requestParameters.count, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This returns a list of accounts.   A token with ORG_ADMIN authority is required to call this API.
		     * @summary Accounts List
		     * @param {AccountsBetaApiListAccountsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof AccountsBetaApi
		     */
		    AccountsBetaApi.prototype.listAccounts = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.AccountsBetaApiFp)(this.configuration).listAccounts(requestParameters.detailLevel, requestParameters.limit, requestParameters.offset, requestParameters.count, requestParameters.filters, requestParameters.sorters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Use this API to update an account with a PUT request.  This endpoint submits an account update task and returns the task ID.   A token with ORG_ADMIN authority is required to call this API. >**NOTE: You can only use this PUT endpoint to update accounts from sources of the \"DelimitedFile\" type.**
		     * @summary Update Account
		     * @param {AccountsBetaApiPutAccountRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof AccountsBetaApi
		     */
		    AccountsBetaApi.prototype.putAccount = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.AccountsBetaApiFp)(this.configuration).putAccount(requestParameters.id, requestParameters.accountAttributesBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API asynchronously reloads the account directly from the connector and performs a one-time aggregation process.   A token with ORG_ADMIN authority is required to call this API.
		     * @summary Reload Account
		     * @param {AccountsBetaApiReloadAccountRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof AccountsBetaApi
		     */
		    AccountsBetaApi.prototype.reloadAccount = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.AccountsBetaApiFp)(this.configuration).reloadAccount(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API submits a task to unlock an account and returns the task ID.   A token with ORG_ADMIN authority is required to call this API.
		     * @summary Unlock Account
		     * @param {AccountsBetaApiUnlockAccountRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof AccountsBetaApi
		     */
		    AccountsBetaApi.prototype.unlockAccount = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.AccountsBetaApiFp)(this.configuration).unlockAccount(requestParameters.id, requestParameters.accountUnlockRequestBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Use this endpoint to update an account with a PATCH request.  The request must provide a JSONPatch payload. A token with ORG_ADMIN authority is required to call this API.
		     * @summary Update Account
		     * @param {AccountsBetaApiUpdateAccountRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof AccountsBetaApi
		     */
		    AccountsBetaApi.prototype.updateAccount = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.AccountsBetaApiFp)(this.configuration).updateAccount(requestParameters.id, requestParameters.requestBody, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return AccountsBetaApi;
		}(base_1.BaseAPI));
		exports.AccountsBetaApi = AccountsBetaApi;
		/**
		 * CertificationCampaignsBetaApi - axios parameter creator
		 * @export
		 */
		var CertificationCampaignsBetaApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * :::caution  This endpoint will run successfully for any campaigns that are **past due**.  This endpoint will return a content error if the campaign is **not past due**.  :::  Completes a certification campaign. This is provided to admins so that they can complete a certification even if all items have not been completed.  Requires roles of CERT_ADMIN and ORG_ADMIN
		         * @summary Complete a Campaign
		         * @param {string} id The campaign id
		         * @param {CompleteCampaignOptionsBeta} [completeCampaignOptionsBeta] Optional. Default behavior is for the campaign to auto-approve upon completion, unless autoCompleteAction&#x3D;REVOKE
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        completeCampaign: function (id, completeCampaignOptionsBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('completeCampaign', 'id', id);
		                            localVarPath = "/campaigns/{id}/complete"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(completeCampaignOptionsBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Creates a new Certification Campaign with the information provided in the request body.
		         * @summary Create a campaign
		         * @param {CampaignBeta} campaignBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        createCampaign: function (campaignBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'campaignBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('createCampaign', 'campaignBeta', campaignBeta);
		                            localVarPath = "/campaigns";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(campaignBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Create a campaign Template based on campaign.
		         * @summary Create a Campaign Template
		         * @param {CampaignTemplateBeta} campaignTemplateBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        createCampaignTemplate: function (campaignTemplateBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'campaignTemplateBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('createCampaignTemplate', 'campaignTemplateBeta', campaignTemplateBeta);
		                            localVarPath = "/campaign-templates";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(campaignTemplateBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Deletes a campaign template by ID.
		         * @summary Delete a Campaign Template
		         * @param {string} id The ID of the campaign template being deleted.
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        deleteCampaignTemplate: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('deleteCampaignTemplate', 'id', id);
		                            localVarPath = "/campaign-templates/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'DELETE' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Deletes the schedule for a campaign template. Returns a 404 if there is no schedule set.
		         * @summary Deletes a Campaign Template\'s Schedule
		         * @param {string} id The ID of the campaign template whose schedule is being deleted.
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        deleteCampaignTemplateSchedule: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('deleteCampaignTemplateSchedule', 'id', id);
		                            localVarPath = "/campaign-templates/{id}/schedule"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'DELETE' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Deletes campaigns whose Ids are specified in the provided list of campaign Ids. Authorized callers must be an ORG_ADMIN or a CERT_ADMIN.
		         * @summary Deletes Campaigns
		         * @param {DeleteCampaignsRequestBeta} deleteCampaignsRequestBeta The ids of the campaigns to delete.
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        deleteCampaigns: function (deleteCampaignsRequestBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'deleteCampaignsRequestBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('deleteCampaigns', 'deleteCampaignsRequestBeta', deleteCampaignsRequestBeta);
		                            localVarPath = "/campaigns/delete";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(deleteCampaignsRequestBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Gets campaigns and returns them in a list. Can provide increased level of detail for each campaign if provided the correct query.
		         * @summary List Campaigns
		         * @param {'SLIM' | 'FULL'} [detail] Determines whether slim, or increased level of detail is provided for each campaign in the returned list. Slim is the default behavior.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **name**: *eq, sw*  **status**: *eq, in*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name, created**
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        getActiveCampaigns: function (detail, limit, offset, count, filters, sorters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/campaigns";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (detail !== undefined) {
		                                localVarQueryParameter['detail'] = detail;
		                            }
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Retrieves information for an existing campaign using the campaign\'s ID. Authorized callers must be a reviewer for this campaign, an ORG_ADMIN, or a CERT_ADMIN.
		         * @summary Get a campaign
		         * @param {string} id The ID of the campaign to be retrieved
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        getCampaign: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getCampaign', 'id', id);
		                            localVarPath = "/campaigns/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Fetches all reports for a certification campaign by campaign ID. Requires roles of CERT_ADMIN, DASHBOARD, ORG_ADMIN and REPORT_ADMIN
		         * @summary Get Campaign Reports
		         * @param {string} id The ID of the campaign for which reports are being fetched.
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        getCampaignReports: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getCampaignReports', 'id', id);
		                            localVarPath = "/campaigns/{id}/reports"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Fetches configuration for campaign reports. Currently it includes only one element - identity attributes defined as custom report columns. Requires roles of CERT_ADMIN and ORG_ADMIN.
		         * @summary Get Campaign Reports Configuration
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        getCampaignReportsConfig: function (axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/campaigns/reports-configuration";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Fetches a campaign template by ID.
		         * @summary Get a Campaign Template
		         * @param {string} id The desired campaign template\&#39;s ID.
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        getCampaignTemplate: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getCampaignTemplate', 'id', id);
		                            localVarPath = "/campaign-templates/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Gets the schedule for a campaign template. Returns a 404 if there is no schedule set.
		         * @summary Gets a Campaign Template\'s Schedule
		         * @param {string} id The ID of the campaign template whose schedule is being fetched.
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        getCampaignTemplateSchedule: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getCampaignTemplateSchedule', 'id', id);
		                            localVarPath = "/campaign-templates/{id}/schedule"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Lists all CampaignTemplates. Scope can be reduced via standard V3 query params.  All CampaignTemplates matching the query params
		         * @summary List Campaign Templates
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name, created, modified**
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **name**: *eq, ge, gt, in, le, lt, ne, sw*  **id**: *eq, ge, gt, in, le, lt, ne, sw*
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        listCampaignTemplates: function (limit, offset, count, sorters, filters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/campaign-templates";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API reassigns the specified certifications from one identity to another. A token with ORG_ADMIN or CERT_ADMIN authority is required to call this API.
		         * @summary Reassign Certifications
		         * @param {string} id The certification campaign ID
		         * @param {AdminReviewReassignBeta} adminReviewReassignBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        move: function (id, adminReviewReassignBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('move', 'id', id);
		                            // verify required parameter 'adminReviewReassignBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('move', 'adminReviewReassignBeta', adminReviewReassignBeta);
		                            localVarPath = "/campaigns/{id}/reassign"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(adminReviewReassignBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Allows updating individual fields on a campaign template using the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.
		         * @summary Update a Campaign Template
		         * @param {string} id The ID of the campaign template being modified.
		         * @param {Array<JsonPatchOperationBeta>} jsonPatchOperationBeta A list of campaign update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.  The following fields are patchable: * name * description * deadlineDuration * campaign (all fields that are allowed during create)
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        patchCampaignTemplate: function (id, jsonPatchOperationBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('patchCampaignTemplate', 'id', id);
		                            // verify required parameter 'jsonPatchOperationBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('patchCampaignTemplate', 'jsonPatchOperationBeta', jsonPatchOperationBeta);
		                            localVarPath = "/campaign-templates/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PATCH' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json-patch+json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(jsonPatchOperationBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Overwrites configuration for campaign reports. Requires roles CERT_ADMIN and ORG_ADMIN.
		         * @summary Set Campaign Reports Configuration
		         * @param {CampaignReportsConfigBeta} campaignReportsConfigBeta Campaign Report Configuration
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        setCampaignReportsConfig: function (campaignReportsConfigBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'campaignReportsConfigBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('setCampaignReportsConfig', 'campaignReportsConfigBeta', campaignReportsConfigBeta);
		                            localVarPath = "/campaigns/reports-configuration";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PUT' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(campaignReportsConfigBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Sets the schedule for a campaign template. If a schedule already exists, it will be overwritten with the new one.
		         * @summary Sets a Campaign Template\'s Schedule
		         * @param {string} id The ID of the campaign template being scheduled.
		         * @param {ScheduleBeta} [scheduleBeta]
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        setCampaignTemplateSchedule: function (id, scheduleBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('setCampaignTemplateSchedule', 'id', id);
		                            localVarPath = "/campaign-templates/{id}/schedule"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PUT' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(scheduleBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Submits a job to activate the campaign with the given Id. The campaign must be staged. Requires roles of CERT_ADMIN and ORG_ADMIN
		         * @summary Activate a Campaign
		         * @param {string} id The campaign id
		         * @param {ActivateCampaignOptionsBeta} [activateCampaignOptionsBeta] Optional. If no timezone is specified, the standard UTC timezone is used (i.e. UTC+00:00). Although this can take any timezone, the intended value is the caller\&#39;s timezone. The activation time calculated from the given timezone may cause the campaign deadline time to be modified, but it will remain within the original date. The timezone must be in a valid ISO 8601 format.
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        startCampaign: function (id, activateCampaignOptionsBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('startCampaign', 'id', id);
		                            localVarPath = "/campaigns/{id}/activate"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(activateCampaignOptionsBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Kicks off remediation scan task for a certification campaign. Requires roles of CERT_ADMIN and ORG_ADMIN
		         * @summary Run Campaign Remediation Scan
		         * @param {string} id The ID of the campaign for which remediation scan is being run.
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        startCampaignRemediationScan: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('startCampaignRemediationScan', 'id', id);
		                            localVarPath = "/campaigns/{id}/run-remediation-scan"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Runs a report for a certification campaign. Requires the following roles: CERT_ADMIN, DASHBOARD, ORG_ADMIN and REPORT_ADMIN.
		         * @summary Run Campaign Report
		         * @param {string} id The ID of the campaign for which report is being run.
		         * @param {ReportTypeBeta} type The type of the report to run.
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        startCampaignReport: function (id, type, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('startCampaignReport', 'id', id);
		                            // verify required parameter 'type' is not null or undefined
		                            (0, common_1.assertParamExists)('startCampaignReport', 'type', type);
		                            localVarPath = "/campaigns/{id}/run-report/{type}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)))
		                                .replace("{".concat("type", "}"), encodeURIComponent(String(type)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Generates a new campaign from a campaign template. The campaign object contained in the template has special formatting applied to its name and description fields in order to determine the generated campaign\'s name/description. Placeholders in those fields are formatted with the current date and time upon generation. Placeholders consist of a percent sign followed by a letter indicating what should be inserted; for example, \"%Y\" will insert the current year; a campaign template named \"Campaign for %y\" would generate a campaign called \"Campaign for 2020\" (assuming the year at generation time is 2020). Valid placeholders are the date/time conversion suffix characters supported by [java.util.Formatter](https://docs.oracle.com/javase/8/docs/api/java/util/Formatter.html). Requires roles ORG_ADMIN.
		         * @summary Generate a Campaign from Template
		         * @param {string} id The ID of the campaign template to use for generation.
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        startGenerateCampaignTemplate: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('startGenerateCampaignTemplate', 'id', id);
		                            localVarPath = "/campaign-templates/{id}/generate"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Allows updating individual fields on a campaign using the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.
		         * @summary Update a Campaign
		         * @param {string} id The ID of the campaign template being modified.
		         * @param {Array<object>} requestBody A list of campaign update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard. The fields that can be patched differ based on the status of the campaign.  In the *STAGED* status, the following fields can be patched: * name * description * recommendationsEnabled * deadline * emailNotificationEnabled * autoRevokeAllowed  In the *ACTIVE* status, the following fields can be patched: * deadline
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        updateCampaign: function (id, requestBody, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('updateCampaign', 'id', id);
		                            // verify required parameter 'requestBody' is not null or undefined
		                            (0, common_1.assertParamExists)('updateCampaign', 'requestBody', requestBody);
		                            localVarPath = "/campaigns/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PATCH' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json-patch+json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(requestBody, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.CertificationCampaignsBetaApiAxiosParamCreator = CertificationCampaignsBetaApiAxiosParamCreator;
		/**
		 * CertificationCampaignsBetaApi - functional programming interface
		 * @export
		 */
		var CertificationCampaignsBetaApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.CertificationCampaignsBetaApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * :::caution  This endpoint will run successfully for any campaigns that are **past due**.  This endpoint will return a content error if the campaign is **not past due**.  :::  Completes a certification campaign. This is provided to admins so that they can complete a certification even if all items have not been completed.  Requires roles of CERT_ADMIN and ORG_ADMIN
		         * @summary Complete a Campaign
		         * @param {string} id The campaign id
		         * @param {CompleteCampaignOptionsBeta} [completeCampaignOptionsBeta] Optional. Default behavior is for the campaign to auto-approve upon completion, unless autoCompleteAction&#x3D;REVOKE
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        completeCampaign: function (id, completeCampaignOptionsBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.completeCampaign(id, completeCampaignOptionsBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Creates a new Certification Campaign with the information provided in the request body.
		         * @summary Create a campaign
		         * @param {CampaignBeta} campaignBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        createCampaign: function (campaignBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.createCampaign(campaignBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Create a campaign Template based on campaign.
		         * @summary Create a Campaign Template
		         * @param {CampaignTemplateBeta} campaignTemplateBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        createCampaignTemplate: function (campaignTemplateBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.createCampaignTemplate(campaignTemplateBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Deletes a campaign template by ID.
		         * @summary Delete a Campaign Template
		         * @param {string} id The ID of the campaign template being deleted.
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        deleteCampaignTemplate: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.deleteCampaignTemplate(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Deletes the schedule for a campaign template. Returns a 404 if there is no schedule set.
		         * @summary Deletes a Campaign Template\'s Schedule
		         * @param {string} id The ID of the campaign template whose schedule is being deleted.
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        deleteCampaignTemplateSchedule: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.deleteCampaignTemplateSchedule(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Deletes campaigns whose Ids are specified in the provided list of campaign Ids. Authorized callers must be an ORG_ADMIN or a CERT_ADMIN.
		         * @summary Deletes Campaigns
		         * @param {DeleteCampaignsRequestBeta} deleteCampaignsRequestBeta The ids of the campaigns to delete.
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        deleteCampaigns: function (deleteCampaignsRequestBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.deleteCampaigns(deleteCampaignsRequestBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Gets campaigns and returns them in a list. Can provide increased level of detail for each campaign if provided the correct query.
		         * @summary List Campaigns
		         * @param {'SLIM' | 'FULL'} [detail] Determines whether slim, or increased level of detail is provided for each campaign in the returned list. Slim is the default behavior.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **name**: *eq, sw*  **status**: *eq, in*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name, created**
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        getActiveCampaigns: function (detail, limit, offset, count, filters, sorters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getActiveCampaigns(detail, limit, offset, count, filters, sorters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Retrieves information for an existing campaign using the campaign\'s ID. Authorized callers must be a reviewer for this campaign, an ORG_ADMIN, or a CERT_ADMIN.
		         * @summary Get a campaign
		         * @param {string} id The ID of the campaign to be retrieved
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        getCampaign: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getCampaign(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Fetches all reports for a certification campaign by campaign ID. Requires roles of CERT_ADMIN, DASHBOARD, ORG_ADMIN and REPORT_ADMIN
		         * @summary Get Campaign Reports
		         * @param {string} id The ID of the campaign for which reports are being fetched.
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        getCampaignReports: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getCampaignReports(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Fetches configuration for campaign reports. Currently it includes only one element - identity attributes defined as custom report columns. Requires roles of CERT_ADMIN and ORG_ADMIN.
		         * @summary Get Campaign Reports Configuration
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        getCampaignReportsConfig: function (axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getCampaignReportsConfig(axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Fetches a campaign template by ID.
		         * @summary Get a Campaign Template
		         * @param {string} id The desired campaign template\&#39;s ID.
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        getCampaignTemplate: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getCampaignTemplate(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Gets the schedule for a campaign template. Returns a 404 if there is no schedule set.
		         * @summary Gets a Campaign Template\'s Schedule
		         * @param {string} id The ID of the campaign template whose schedule is being fetched.
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        getCampaignTemplateSchedule: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getCampaignTemplateSchedule(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Lists all CampaignTemplates. Scope can be reduced via standard V3 query params.  All CampaignTemplates matching the query params
		         * @summary List Campaign Templates
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name, created, modified**
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **name**: *eq, ge, gt, in, le, lt, ne, sw*  **id**: *eq, ge, gt, in, le, lt, ne, sw*
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        listCampaignTemplates: function (limit, offset, count, sorters, filters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listCampaignTemplates(limit, offset, count, sorters, filters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API reassigns the specified certifications from one identity to another. A token with ORG_ADMIN or CERT_ADMIN authority is required to call this API.
		         * @summary Reassign Certifications
		         * @param {string} id The certification campaign ID
		         * @param {AdminReviewReassignBeta} adminReviewReassignBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        move: function (id, adminReviewReassignBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.move(id, adminReviewReassignBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Allows updating individual fields on a campaign template using the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.
		         * @summary Update a Campaign Template
		         * @param {string} id The ID of the campaign template being modified.
		         * @param {Array<JsonPatchOperationBeta>} jsonPatchOperationBeta A list of campaign update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.  The following fields are patchable: * name * description * deadlineDuration * campaign (all fields that are allowed during create)
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        patchCampaignTemplate: function (id, jsonPatchOperationBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.patchCampaignTemplate(id, jsonPatchOperationBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Overwrites configuration for campaign reports. Requires roles CERT_ADMIN and ORG_ADMIN.
		         * @summary Set Campaign Reports Configuration
		         * @param {CampaignReportsConfigBeta} campaignReportsConfigBeta Campaign Report Configuration
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        setCampaignReportsConfig: function (campaignReportsConfigBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.setCampaignReportsConfig(campaignReportsConfigBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Sets the schedule for a campaign template. If a schedule already exists, it will be overwritten with the new one.
		         * @summary Sets a Campaign Template\'s Schedule
		         * @param {string} id The ID of the campaign template being scheduled.
		         * @param {ScheduleBeta} [scheduleBeta]
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        setCampaignTemplateSchedule: function (id, scheduleBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.setCampaignTemplateSchedule(id, scheduleBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Submits a job to activate the campaign with the given Id. The campaign must be staged. Requires roles of CERT_ADMIN and ORG_ADMIN
		         * @summary Activate a Campaign
		         * @param {string} id The campaign id
		         * @param {ActivateCampaignOptionsBeta} [activateCampaignOptionsBeta] Optional. If no timezone is specified, the standard UTC timezone is used (i.e. UTC+00:00). Although this can take any timezone, the intended value is the caller\&#39;s timezone. The activation time calculated from the given timezone may cause the campaign deadline time to be modified, but it will remain within the original date. The timezone must be in a valid ISO 8601 format.
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        startCampaign: function (id, activateCampaignOptionsBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.startCampaign(id, activateCampaignOptionsBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Kicks off remediation scan task for a certification campaign. Requires roles of CERT_ADMIN and ORG_ADMIN
		         * @summary Run Campaign Remediation Scan
		         * @param {string} id The ID of the campaign for which remediation scan is being run.
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        startCampaignRemediationScan: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.startCampaignRemediationScan(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Runs a report for a certification campaign. Requires the following roles: CERT_ADMIN, DASHBOARD, ORG_ADMIN and REPORT_ADMIN.
		         * @summary Run Campaign Report
		         * @param {string} id The ID of the campaign for which report is being run.
		         * @param {ReportTypeBeta} type The type of the report to run.
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        startCampaignReport: function (id, type, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.startCampaignReport(id, type, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Generates a new campaign from a campaign template. The campaign object contained in the template has special formatting applied to its name and description fields in order to determine the generated campaign\'s name/description. Placeholders in those fields are formatted with the current date and time upon generation. Placeholders consist of a percent sign followed by a letter indicating what should be inserted; for example, \"%Y\" will insert the current year; a campaign template named \"Campaign for %y\" would generate a campaign called \"Campaign for 2020\" (assuming the year at generation time is 2020). Valid placeholders are the date/time conversion suffix characters supported by [java.util.Formatter](https://docs.oracle.com/javase/8/docs/api/java/util/Formatter.html). Requires roles ORG_ADMIN.
		         * @summary Generate a Campaign from Template
		         * @param {string} id The ID of the campaign template to use for generation.
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        startGenerateCampaignTemplate: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.startGenerateCampaignTemplate(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Allows updating individual fields on a campaign using the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.
		         * @summary Update a Campaign
		         * @param {string} id The ID of the campaign template being modified.
		         * @param {Array<object>} requestBody A list of campaign update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard. The fields that can be patched differ based on the status of the campaign.  In the *STAGED* status, the following fields can be patched: * name * description * recommendationsEnabled * deadline * emailNotificationEnabled * autoRevokeAllowed  In the *ACTIVE* status, the following fields can be patched: * deadline
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        updateCampaign: function (id, requestBody, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.updateCampaign(id, requestBody, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.CertificationCampaignsBetaApiFp = CertificationCampaignsBetaApiFp;
		/**
		 * CertificationCampaignsBetaApi - factory interface
		 * @export
		 */
		var CertificationCampaignsBetaApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.CertificationCampaignsBetaApiFp)(configuration);
		    return {
		        /**
		         * :::caution  This endpoint will run successfully for any campaigns that are **past due**.  This endpoint will return a content error if the campaign is **not past due**.  :::  Completes a certification campaign. This is provided to admins so that they can complete a certification even if all items have not been completed.  Requires roles of CERT_ADMIN and ORG_ADMIN
		         * @summary Complete a Campaign
		         * @param {string} id The campaign id
		         * @param {CompleteCampaignOptionsBeta} [completeCampaignOptionsBeta] Optional. Default behavior is for the campaign to auto-approve upon completion, unless autoCompleteAction&#x3D;REVOKE
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        completeCampaign: function (id, completeCampaignOptionsBeta, axiosOptions) {
		            return localVarFp.completeCampaign(id, completeCampaignOptionsBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Creates a new Certification Campaign with the information provided in the request body.
		         * @summary Create a campaign
		         * @param {CampaignBeta} campaignBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        createCampaign: function (campaignBeta, axiosOptions) {
		            return localVarFp.createCampaign(campaignBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Create a campaign Template based on campaign.
		         * @summary Create a Campaign Template
		         * @param {CampaignTemplateBeta} campaignTemplateBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        createCampaignTemplate: function (campaignTemplateBeta, axiosOptions) {
		            return localVarFp.createCampaignTemplate(campaignTemplateBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Deletes a campaign template by ID.
		         * @summary Delete a Campaign Template
		         * @param {string} id The ID of the campaign template being deleted.
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        deleteCampaignTemplate: function (id, axiosOptions) {
		            return localVarFp.deleteCampaignTemplate(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Deletes the schedule for a campaign template. Returns a 404 if there is no schedule set.
		         * @summary Deletes a Campaign Template\'s Schedule
		         * @param {string} id The ID of the campaign template whose schedule is being deleted.
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        deleteCampaignTemplateSchedule: function (id, axiosOptions) {
		            return localVarFp.deleteCampaignTemplateSchedule(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Deletes campaigns whose Ids are specified in the provided list of campaign Ids. Authorized callers must be an ORG_ADMIN or a CERT_ADMIN.
		         * @summary Deletes Campaigns
		         * @param {DeleteCampaignsRequestBeta} deleteCampaignsRequestBeta The ids of the campaigns to delete.
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        deleteCampaigns: function (deleteCampaignsRequestBeta, axiosOptions) {
		            return localVarFp.deleteCampaigns(deleteCampaignsRequestBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Gets campaigns and returns them in a list. Can provide increased level of detail for each campaign if provided the correct query.
		         * @summary List Campaigns
		         * @param {'SLIM' | 'FULL'} [detail] Determines whether slim, or increased level of detail is provided for each campaign in the returned list. Slim is the default behavior.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **name**: *eq, sw*  **status**: *eq, in*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name, created**
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        getActiveCampaigns: function (detail, limit, offset, count, filters, sorters, axiosOptions) {
		            return localVarFp.getActiveCampaigns(detail, limit, offset, count, filters, sorters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Retrieves information for an existing campaign using the campaign\'s ID. Authorized callers must be a reviewer for this campaign, an ORG_ADMIN, or a CERT_ADMIN.
		         * @summary Get a campaign
		         * @param {string} id The ID of the campaign to be retrieved
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        getCampaign: function (id, axiosOptions) {
		            return localVarFp.getCampaign(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Fetches all reports for a certification campaign by campaign ID. Requires roles of CERT_ADMIN, DASHBOARD, ORG_ADMIN and REPORT_ADMIN
		         * @summary Get Campaign Reports
		         * @param {string} id The ID of the campaign for which reports are being fetched.
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        getCampaignReports: function (id, axiosOptions) {
		            return localVarFp.getCampaignReports(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Fetches configuration for campaign reports. Currently it includes only one element - identity attributes defined as custom report columns. Requires roles of CERT_ADMIN and ORG_ADMIN.
		         * @summary Get Campaign Reports Configuration
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        getCampaignReportsConfig: function (axiosOptions) {
		            return localVarFp.getCampaignReportsConfig(axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Fetches a campaign template by ID.
		         * @summary Get a Campaign Template
		         * @param {string} id The desired campaign template\&#39;s ID.
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        getCampaignTemplate: function (id, axiosOptions) {
		            return localVarFp.getCampaignTemplate(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Gets the schedule for a campaign template. Returns a 404 if there is no schedule set.
		         * @summary Gets a Campaign Template\'s Schedule
		         * @param {string} id The ID of the campaign template whose schedule is being fetched.
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        getCampaignTemplateSchedule: function (id, axiosOptions) {
		            return localVarFp.getCampaignTemplateSchedule(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Lists all CampaignTemplates. Scope can be reduced via standard V3 query params.  All CampaignTemplates matching the query params
		         * @summary List Campaign Templates
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name, created, modified**
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **name**: *eq, ge, gt, in, le, lt, ne, sw*  **id**: *eq, ge, gt, in, le, lt, ne, sw*
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        listCampaignTemplates: function (limit, offset, count, sorters, filters, axiosOptions) {
		            return localVarFp.listCampaignTemplates(limit, offset, count, sorters, filters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API reassigns the specified certifications from one identity to another. A token with ORG_ADMIN or CERT_ADMIN authority is required to call this API.
		         * @summary Reassign Certifications
		         * @param {string} id The certification campaign ID
		         * @param {AdminReviewReassignBeta} adminReviewReassignBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        move: function (id, adminReviewReassignBeta, axiosOptions) {
		            return localVarFp.move(id, adminReviewReassignBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Allows updating individual fields on a campaign template using the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.
		         * @summary Update a Campaign Template
		         * @param {string} id The ID of the campaign template being modified.
		         * @param {Array<JsonPatchOperationBeta>} jsonPatchOperationBeta A list of campaign update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.  The following fields are patchable: * name * description * deadlineDuration * campaign (all fields that are allowed during create)
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        patchCampaignTemplate: function (id, jsonPatchOperationBeta, axiosOptions) {
		            return localVarFp.patchCampaignTemplate(id, jsonPatchOperationBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Overwrites configuration for campaign reports. Requires roles CERT_ADMIN and ORG_ADMIN.
		         * @summary Set Campaign Reports Configuration
		         * @param {CampaignReportsConfigBeta} campaignReportsConfigBeta Campaign Report Configuration
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        setCampaignReportsConfig: function (campaignReportsConfigBeta, axiosOptions) {
		            return localVarFp.setCampaignReportsConfig(campaignReportsConfigBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Sets the schedule for a campaign template. If a schedule already exists, it will be overwritten with the new one.
		         * @summary Sets a Campaign Template\'s Schedule
		         * @param {string} id The ID of the campaign template being scheduled.
		         * @param {ScheduleBeta} [scheduleBeta]
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        setCampaignTemplateSchedule: function (id, scheduleBeta, axiosOptions) {
		            return localVarFp.setCampaignTemplateSchedule(id, scheduleBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Submits a job to activate the campaign with the given Id. The campaign must be staged. Requires roles of CERT_ADMIN and ORG_ADMIN
		         * @summary Activate a Campaign
		         * @param {string} id The campaign id
		         * @param {ActivateCampaignOptionsBeta} [activateCampaignOptionsBeta] Optional. If no timezone is specified, the standard UTC timezone is used (i.e. UTC+00:00). Although this can take any timezone, the intended value is the caller\&#39;s timezone. The activation time calculated from the given timezone may cause the campaign deadline time to be modified, but it will remain within the original date. The timezone must be in a valid ISO 8601 format.
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        startCampaign: function (id, activateCampaignOptionsBeta, axiosOptions) {
		            return localVarFp.startCampaign(id, activateCampaignOptionsBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Kicks off remediation scan task for a certification campaign. Requires roles of CERT_ADMIN and ORG_ADMIN
		         * @summary Run Campaign Remediation Scan
		         * @param {string} id The ID of the campaign for which remediation scan is being run.
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        startCampaignRemediationScan: function (id, axiosOptions) {
		            return localVarFp.startCampaignRemediationScan(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Runs a report for a certification campaign. Requires the following roles: CERT_ADMIN, DASHBOARD, ORG_ADMIN and REPORT_ADMIN.
		         * @summary Run Campaign Report
		         * @param {string} id The ID of the campaign for which report is being run.
		         * @param {ReportTypeBeta} type The type of the report to run.
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        startCampaignReport: function (id, type, axiosOptions) {
		            return localVarFp.startCampaignReport(id, type, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Generates a new campaign from a campaign template. The campaign object contained in the template has special formatting applied to its name and description fields in order to determine the generated campaign\'s name/description. Placeholders in those fields are formatted with the current date and time upon generation. Placeholders consist of a percent sign followed by a letter indicating what should be inserted; for example, \"%Y\" will insert the current year; a campaign template named \"Campaign for %y\" would generate a campaign called \"Campaign for 2020\" (assuming the year at generation time is 2020). Valid placeholders are the date/time conversion suffix characters supported by [java.util.Formatter](https://docs.oracle.com/javase/8/docs/api/java/util/Formatter.html). Requires roles ORG_ADMIN.
		         * @summary Generate a Campaign from Template
		         * @param {string} id The ID of the campaign template to use for generation.
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        startGenerateCampaignTemplate: function (id, axiosOptions) {
		            return localVarFp.startGenerateCampaignTemplate(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Allows updating individual fields on a campaign using the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.
		         * @summary Update a Campaign
		         * @param {string} id The ID of the campaign template being modified.
		         * @param {Array<object>} requestBody A list of campaign update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard. The fields that can be patched differ based on the status of the campaign.  In the *STAGED* status, the following fields can be patched: * name * description * recommendationsEnabled * deadline * emailNotificationEnabled * autoRevokeAllowed  In the *ACTIVE* status, the following fields can be patched: * deadline
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        updateCampaign: function (id, requestBody, axiosOptions) {
		            return localVarFp.updateCampaign(id, requestBody, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.CertificationCampaignsBetaApiFactory = CertificationCampaignsBetaApiFactory;
		/**
		 * CertificationCampaignsBetaApi - object-oriented interface
		 * @export
		 * @class CertificationCampaignsBetaApi
		 * @extends {BaseAPI}
		 */
		var CertificationCampaignsBetaApi = /** @class */ (function (_super) {
		    __extends(CertificationCampaignsBetaApi, _super);
		    function CertificationCampaignsBetaApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * :::caution  This endpoint will run successfully for any campaigns that are **past due**.  This endpoint will return a content error if the campaign is **not past due**.  :::  Completes a certification campaign. This is provided to admins so that they can complete a certification even if all items have not been completed.  Requires roles of CERT_ADMIN and ORG_ADMIN
		     * @summary Complete a Campaign
		     * @param {CertificationCampaignsBetaApiCompleteCampaignRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @deprecated
		     * @throws {RequiredError}
		     * @memberof CertificationCampaignsBetaApi
		     */
		    CertificationCampaignsBetaApi.prototype.completeCampaign = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.CertificationCampaignsBetaApiFp)(this.configuration).completeCampaign(requestParameters.id, requestParameters.completeCampaignOptionsBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Creates a new Certification Campaign with the information provided in the request body.
		     * @summary Create a campaign
		     * @param {CertificationCampaignsBetaApiCreateCampaignRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @deprecated
		     * @throws {RequiredError}
		     * @memberof CertificationCampaignsBetaApi
		     */
		    CertificationCampaignsBetaApi.prototype.createCampaign = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.CertificationCampaignsBetaApiFp)(this.configuration).createCampaign(requestParameters.campaignBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Create a campaign Template based on campaign.
		     * @summary Create a Campaign Template
		     * @param {CertificationCampaignsBetaApiCreateCampaignTemplateRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @deprecated
		     * @throws {RequiredError}
		     * @memberof CertificationCampaignsBetaApi
		     */
		    CertificationCampaignsBetaApi.prototype.createCampaignTemplate = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.CertificationCampaignsBetaApiFp)(this.configuration).createCampaignTemplate(requestParameters.campaignTemplateBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Deletes a campaign template by ID.
		     * @summary Delete a Campaign Template
		     * @param {CertificationCampaignsBetaApiDeleteCampaignTemplateRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @deprecated
		     * @throws {RequiredError}
		     * @memberof CertificationCampaignsBetaApi
		     */
		    CertificationCampaignsBetaApi.prototype.deleteCampaignTemplate = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.CertificationCampaignsBetaApiFp)(this.configuration).deleteCampaignTemplate(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Deletes the schedule for a campaign template. Returns a 404 if there is no schedule set.
		     * @summary Deletes a Campaign Template\'s Schedule
		     * @param {CertificationCampaignsBetaApiDeleteCampaignTemplateScheduleRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @deprecated
		     * @throws {RequiredError}
		     * @memberof CertificationCampaignsBetaApi
		     */
		    CertificationCampaignsBetaApi.prototype.deleteCampaignTemplateSchedule = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.CertificationCampaignsBetaApiFp)(this.configuration).deleteCampaignTemplateSchedule(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Deletes campaigns whose Ids are specified in the provided list of campaign Ids. Authorized callers must be an ORG_ADMIN or a CERT_ADMIN.
		     * @summary Deletes Campaigns
		     * @param {CertificationCampaignsBetaApiDeleteCampaignsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @deprecated
		     * @throws {RequiredError}
		     * @memberof CertificationCampaignsBetaApi
		     */
		    CertificationCampaignsBetaApi.prototype.deleteCampaigns = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.CertificationCampaignsBetaApiFp)(this.configuration).deleteCampaigns(requestParameters.deleteCampaignsRequestBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Gets campaigns and returns them in a list. Can provide increased level of detail for each campaign if provided the correct query.
		     * @summary List Campaigns
		     * @param {CertificationCampaignsBetaApiGetActiveCampaignsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @deprecated
		     * @throws {RequiredError}
		     * @memberof CertificationCampaignsBetaApi
		     */
		    CertificationCampaignsBetaApi.prototype.getActiveCampaigns = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.CertificationCampaignsBetaApiFp)(this.configuration).getActiveCampaigns(requestParameters.detail, requestParameters.limit, requestParameters.offset, requestParameters.count, requestParameters.filters, requestParameters.sorters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Retrieves information for an existing campaign using the campaign\'s ID. Authorized callers must be a reviewer for this campaign, an ORG_ADMIN, or a CERT_ADMIN.
		     * @summary Get a campaign
		     * @param {CertificationCampaignsBetaApiGetCampaignRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @deprecated
		     * @throws {RequiredError}
		     * @memberof CertificationCampaignsBetaApi
		     */
		    CertificationCampaignsBetaApi.prototype.getCampaign = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.CertificationCampaignsBetaApiFp)(this.configuration).getCampaign(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Fetches all reports for a certification campaign by campaign ID. Requires roles of CERT_ADMIN, DASHBOARD, ORG_ADMIN and REPORT_ADMIN
		     * @summary Get Campaign Reports
		     * @param {CertificationCampaignsBetaApiGetCampaignReportsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @deprecated
		     * @throws {RequiredError}
		     * @memberof CertificationCampaignsBetaApi
		     */
		    CertificationCampaignsBetaApi.prototype.getCampaignReports = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.CertificationCampaignsBetaApiFp)(this.configuration).getCampaignReports(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Fetches configuration for campaign reports. Currently it includes only one element - identity attributes defined as custom report columns. Requires roles of CERT_ADMIN and ORG_ADMIN.
		     * @summary Get Campaign Reports Configuration
		     * @param {*} [axiosOptions] Override http request option.
		     * @deprecated
		     * @throws {RequiredError}
		     * @memberof CertificationCampaignsBetaApi
		     */
		    CertificationCampaignsBetaApi.prototype.getCampaignReportsConfig = function (axiosOptions) {
		        var _this = this;
		        return (0, exports.CertificationCampaignsBetaApiFp)(this.configuration).getCampaignReportsConfig(axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Fetches a campaign template by ID.
		     * @summary Get a Campaign Template
		     * @param {CertificationCampaignsBetaApiGetCampaignTemplateRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @deprecated
		     * @throws {RequiredError}
		     * @memberof CertificationCampaignsBetaApi
		     */
		    CertificationCampaignsBetaApi.prototype.getCampaignTemplate = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.CertificationCampaignsBetaApiFp)(this.configuration).getCampaignTemplate(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Gets the schedule for a campaign template. Returns a 404 if there is no schedule set.
		     * @summary Gets a Campaign Template\'s Schedule
		     * @param {CertificationCampaignsBetaApiGetCampaignTemplateScheduleRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @deprecated
		     * @throws {RequiredError}
		     * @memberof CertificationCampaignsBetaApi
		     */
		    CertificationCampaignsBetaApi.prototype.getCampaignTemplateSchedule = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.CertificationCampaignsBetaApiFp)(this.configuration).getCampaignTemplateSchedule(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Lists all CampaignTemplates. Scope can be reduced via standard V3 query params.  All CampaignTemplates matching the query params
		     * @summary List Campaign Templates
		     * @param {CertificationCampaignsBetaApiListCampaignTemplatesRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @deprecated
		     * @throws {RequiredError}
		     * @memberof CertificationCampaignsBetaApi
		     */
		    CertificationCampaignsBetaApi.prototype.listCampaignTemplates = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.CertificationCampaignsBetaApiFp)(this.configuration).listCampaignTemplates(requestParameters.limit, requestParameters.offset, requestParameters.count, requestParameters.sorters, requestParameters.filters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API reassigns the specified certifications from one identity to another. A token with ORG_ADMIN or CERT_ADMIN authority is required to call this API.
		     * @summary Reassign Certifications
		     * @param {CertificationCampaignsBetaApiMoveRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @deprecated
		     * @throws {RequiredError}
		     * @memberof CertificationCampaignsBetaApi
		     */
		    CertificationCampaignsBetaApi.prototype.move = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.CertificationCampaignsBetaApiFp)(this.configuration).move(requestParameters.id, requestParameters.adminReviewReassignBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Allows updating individual fields on a campaign template using the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.
		     * @summary Update a Campaign Template
		     * @param {CertificationCampaignsBetaApiPatchCampaignTemplateRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @deprecated
		     * @throws {RequiredError}
		     * @memberof CertificationCampaignsBetaApi
		     */
		    CertificationCampaignsBetaApi.prototype.patchCampaignTemplate = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.CertificationCampaignsBetaApiFp)(this.configuration).patchCampaignTemplate(requestParameters.id, requestParameters.jsonPatchOperationBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Overwrites configuration for campaign reports. Requires roles CERT_ADMIN and ORG_ADMIN.
		     * @summary Set Campaign Reports Configuration
		     * @param {CertificationCampaignsBetaApiSetCampaignReportsConfigRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @deprecated
		     * @throws {RequiredError}
		     * @memberof CertificationCampaignsBetaApi
		     */
		    CertificationCampaignsBetaApi.prototype.setCampaignReportsConfig = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.CertificationCampaignsBetaApiFp)(this.configuration).setCampaignReportsConfig(requestParameters.campaignReportsConfigBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Sets the schedule for a campaign template. If a schedule already exists, it will be overwritten with the new one.
		     * @summary Sets a Campaign Template\'s Schedule
		     * @param {CertificationCampaignsBetaApiSetCampaignTemplateScheduleRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @deprecated
		     * @throws {RequiredError}
		     * @memberof CertificationCampaignsBetaApi
		     */
		    CertificationCampaignsBetaApi.prototype.setCampaignTemplateSchedule = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.CertificationCampaignsBetaApiFp)(this.configuration).setCampaignTemplateSchedule(requestParameters.id, requestParameters.scheduleBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Submits a job to activate the campaign with the given Id. The campaign must be staged. Requires roles of CERT_ADMIN and ORG_ADMIN
		     * @summary Activate a Campaign
		     * @param {CertificationCampaignsBetaApiStartCampaignRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @deprecated
		     * @throws {RequiredError}
		     * @memberof CertificationCampaignsBetaApi
		     */
		    CertificationCampaignsBetaApi.prototype.startCampaign = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.CertificationCampaignsBetaApiFp)(this.configuration).startCampaign(requestParameters.id, requestParameters.activateCampaignOptionsBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Kicks off remediation scan task for a certification campaign. Requires roles of CERT_ADMIN and ORG_ADMIN
		     * @summary Run Campaign Remediation Scan
		     * @param {CertificationCampaignsBetaApiStartCampaignRemediationScanRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @deprecated
		     * @throws {RequiredError}
		     * @memberof CertificationCampaignsBetaApi
		     */
		    CertificationCampaignsBetaApi.prototype.startCampaignRemediationScan = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.CertificationCampaignsBetaApiFp)(this.configuration).startCampaignRemediationScan(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Runs a report for a certification campaign. Requires the following roles: CERT_ADMIN, DASHBOARD, ORG_ADMIN and REPORT_ADMIN.
		     * @summary Run Campaign Report
		     * @param {CertificationCampaignsBetaApiStartCampaignReportRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @deprecated
		     * @throws {RequiredError}
		     * @memberof CertificationCampaignsBetaApi
		     */
		    CertificationCampaignsBetaApi.prototype.startCampaignReport = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.CertificationCampaignsBetaApiFp)(this.configuration).startCampaignReport(requestParameters.id, requestParameters.type, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Generates a new campaign from a campaign template. The campaign object contained in the template has special formatting applied to its name and description fields in order to determine the generated campaign\'s name/description. Placeholders in those fields are formatted with the current date and time upon generation. Placeholders consist of a percent sign followed by a letter indicating what should be inserted; for example, \"%Y\" will insert the current year; a campaign template named \"Campaign for %y\" would generate a campaign called \"Campaign for 2020\" (assuming the year at generation time is 2020). Valid placeholders are the date/time conversion suffix characters supported by [java.util.Formatter](https://docs.oracle.com/javase/8/docs/api/java/util/Formatter.html). Requires roles ORG_ADMIN.
		     * @summary Generate a Campaign from Template
		     * @param {CertificationCampaignsBetaApiStartGenerateCampaignTemplateRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @deprecated
		     * @throws {RequiredError}
		     * @memberof CertificationCampaignsBetaApi
		     */
		    CertificationCampaignsBetaApi.prototype.startGenerateCampaignTemplate = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.CertificationCampaignsBetaApiFp)(this.configuration).startGenerateCampaignTemplate(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Allows updating individual fields on a campaign using the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.
		     * @summary Update a Campaign
		     * @param {CertificationCampaignsBetaApiUpdateCampaignRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @deprecated
		     * @throws {RequiredError}
		     * @memberof CertificationCampaignsBetaApi
		     */
		    CertificationCampaignsBetaApi.prototype.updateCampaign = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.CertificationCampaignsBetaApiFp)(this.configuration).updateCampaign(requestParameters.id, requestParameters.requestBody, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return CertificationCampaignsBetaApi;
		}(base_1.BaseAPI));
		exports.CertificationCampaignsBetaApi = CertificationCampaignsBetaApi;
		/**
		 * CertificationsBetaApi - axios parameter creator
		 * @export
		 */
		var CertificationsBetaApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * This API returns the permissions associated with an entitlement certification item based on the certification item\'s ID. A token with ORG_ADMIN or CERT_ADMIN authority is required to call this API. Reviewers for this certification can also call this API.
		         * @summary Permissions for Entitlement Certification Item
		         * @param {string} certificationId The certification ID
		         * @param {string} itemId The certification item ID
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **target**: *eq, sw*  **rights**: *ca*  All field values (second filter operands) are case-insensitive for this API.  Only a single *and* or *or* composite filter operator may be used. It must also be used between a target filter and a rights filter, not between 2 filters for the same field.  For example, the following is valid: &#x60;?filters&#x3D;rights+ca+(%22CREATE%22)+and+target+eq+%22SYS.OBJAUTH2%22&#x60;  The following is invalid: &#x60;?filters&#x3D;rights+ca+(%22CREATE%22)+and+rights+ca+(%SELECT%22)&#x60;
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        getIdentityCertificationItemPermissions: function (certificationId, itemId, filters, limit, offset, count, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'certificationId' is not null or undefined
		                            (0, common_1.assertParamExists)('getIdentityCertificationItemPermissions', 'certificationId', certificationId);
		                            // verify required parameter 'itemId' is not null or undefined
		                            (0, common_1.assertParamExists)('getIdentityCertificationItemPermissions', 'itemId', itemId);
		                            localVarPath = "/certifications/{certificationId}/access-review-items/{itemId}/permissions"
		                                .replace("{".concat("certificationId", "}"), encodeURIComponent(String(certificationId)))
		                                .replace("{".concat("itemId", "}"), encodeURIComponent(String(itemId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns the status of all pending (`QUEUED` or `IN_PROGRESS`) tasks for an identity campaign certification. A token with ORG_ADMIN or CERT_ADMIN authority is required to call this API. Reviewers for this certification can also call this API.
		         * @summary Pending Certification Tasks
		         * @param {string} id The identity campaign certification ID
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getIdentityCertificationPendingTasks: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getIdentityCertificationPendingTasks', 'id', id);
		                            localVarPath = "/certifications/{id}/tasks-pending"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns the status of a certification task. A token with ORG_ADMIN or CERT_ADMIN authority is required to call this API. Reviewers for this certification can also call this API.
		         * @summary Certification Task Status
		         * @param {string} id The identity campaign certification ID
		         * @param {string} taskId The certification task ID
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getIdentityCertificationTaskStatus: function (id, taskId, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getIdentityCertificationTaskStatus', 'id', id);
		                            // verify required parameter 'taskId' is not null or undefined
		                            (0, common_1.assertParamExists)('getIdentityCertificationTaskStatus', 'taskId', taskId);
		                            localVarPath = "/certifications/{id}/tasks/{taskId}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)))
		                                .replace("{".concat("taskId", "}"), encodeURIComponent(String(taskId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns a list of reviewers for the certification. A token with ORG_ADMIN or CERT_ADMIN authority is required to call this API. Reviewers for this certification can also call this API.
		         * @summary List of Reviewers for certification
		         * @param {string} id The certification ID
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **name**: *eq, sw*  **email**: *eq, sw*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name, email**
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        listCertificationReviewers: function (id, limit, offset, count, filters, sorters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('listCertificationReviewers', 'id', id);
		                            localVarPath = "/certifications/{id}/reviewers"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API initiates a task to reassign up to 500 identities or items in an identity campaign certification to another reviewer. The `certification-tasks` API can be used to get an updated status on the task and determine when the reassignment is complete. A token with ORG_ADMIN or CERT_ADMIN authority is required to call this API. Reviewers for this certification can also call this API.
		         * @summary Reassign Certifications Asynchronously
		         * @param {string} id The identity campaign certification ID
		         * @param {ReviewReassignBeta} reviewReassignBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        submitReassignCertsAsync: function (id, reviewReassignBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('submitReassignCertsAsync', 'id', id);
		                            // verify required parameter 'reviewReassignBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('submitReassignCertsAsync', 'reviewReassignBeta', reviewReassignBeta);
		                            localVarPath = "/certifications/{id}/reassign-async"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(reviewReassignBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.CertificationsBetaApiAxiosParamCreator = CertificationsBetaApiAxiosParamCreator;
		/**
		 * CertificationsBetaApi - functional programming interface
		 * @export
		 */
		var CertificationsBetaApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.CertificationsBetaApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * This API returns the permissions associated with an entitlement certification item based on the certification item\'s ID. A token with ORG_ADMIN or CERT_ADMIN authority is required to call this API. Reviewers for this certification can also call this API.
		         * @summary Permissions for Entitlement Certification Item
		         * @param {string} certificationId The certification ID
		         * @param {string} itemId The certification item ID
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **target**: *eq, sw*  **rights**: *ca*  All field values (second filter operands) are case-insensitive for this API.  Only a single *and* or *or* composite filter operator may be used. It must also be used between a target filter and a rights filter, not between 2 filters for the same field.  For example, the following is valid: &#x60;?filters&#x3D;rights+ca+(%22CREATE%22)+and+target+eq+%22SYS.OBJAUTH2%22&#x60;  The following is invalid: &#x60;?filters&#x3D;rights+ca+(%22CREATE%22)+and+rights+ca+(%SELECT%22)&#x60;
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        getIdentityCertificationItemPermissions: function (certificationId, itemId, filters, limit, offset, count, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getIdentityCertificationItemPermissions(certificationId, itemId, filters, limit, offset, count, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns the status of all pending (`QUEUED` or `IN_PROGRESS`) tasks for an identity campaign certification. A token with ORG_ADMIN or CERT_ADMIN authority is required to call this API. Reviewers for this certification can also call this API.
		         * @summary Pending Certification Tasks
		         * @param {string} id The identity campaign certification ID
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getIdentityCertificationPendingTasks: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getIdentityCertificationPendingTasks(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns the status of a certification task. A token with ORG_ADMIN or CERT_ADMIN authority is required to call this API. Reviewers for this certification can also call this API.
		         * @summary Certification Task Status
		         * @param {string} id The identity campaign certification ID
		         * @param {string} taskId The certification task ID
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getIdentityCertificationTaskStatus: function (id, taskId, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getIdentityCertificationTaskStatus(id, taskId, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns a list of reviewers for the certification. A token with ORG_ADMIN or CERT_ADMIN authority is required to call this API. Reviewers for this certification can also call this API.
		         * @summary List of Reviewers for certification
		         * @param {string} id The certification ID
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **name**: *eq, sw*  **email**: *eq, sw*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name, email**
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        listCertificationReviewers: function (id, limit, offset, count, filters, sorters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listCertificationReviewers(id, limit, offset, count, filters, sorters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API initiates a task to reassign up to 500 identities or items in an identity campaign certification to another reviewer. The `certification-tasks` API can be used to get an updated status on the task and determine when the reassignment is complete. A token with ORG_ADMIN or CERT_ADMIN authority is required to call this API. Reviewers for this certification can also call this API.
		         * @summary Reassign Certifications Asynchronously
		         * @param {string} id The identity campaign certification ID
		         * @param {ReviewReassignBeta} reviewReassignBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        submitReassignCertsAsync: function (id, reviewReassignBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.submitReassignCertsAsync(id, reviewReassignBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.CertificationsBetaApiFp = CertificationsBetaApiFp;
		/**
		 * CertificationsBetaApi - factory interface
		 * @export
		 */
		var CertificationsBetaApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.CertificationsBetaApiFp)(configuration);
		    return {
		        /**
		         * This API returns the permissions associated with an entitlement certification item based on the certification item\'s ID. A token with ORG_ADMIN or CERT_ADMIN authority is required to call this API. Reviewers for this certification can also call this API.
		         * @summary Permissions for Entitlement Certification Item
		         * @param {string} certificationId The certification ID
		         * @param {string} itemId The certification item ID
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **target**: *eq, sw*  **rights**: *ca*  All field values (second filter operands) are case-insensitive for this API.  Only a single *and* or *or* composite filter operator may be used. It must also be used between a target filter and a rights filter, not between 2 filters for the same field.  For example, the following is valid: &#x60;?filters&#x3D;rights+ca+(%22CREATE%22)+and+target+eq+%22SYS.OBJAUTH2%22&#x60;  The following is invalid: &#x60;?filters&#x3D;rights+ca+(%22CREATE%22)+and+rights+ca+(%SELECT%22)&#x60;
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        getIdentityCertificationItemPermissions: function (certificationId, itemId, filters, limit, offset, count, axiosOptions) {
		            return localVarFp.getIdentityCertificationItemPermissions(certificationId, itemId, filters, limit, offset, count, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API returns the status of all pending (`QUEUED` or `IN_PROGRESS`) tasks for an identity campaign certification. A token with ORG_ADMIN or CERT_ADMIN authority is required to call this API. Reviewers for this certification can also call this API.
		         * @summary Pending Certification Tasks
		         * @param {string} id The identity campaign certification ID
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getIdentityCertificationPendingTasks: function (id, axiosOptions) {
		            return localVarFp.getIdentityCertificationPendingTasks(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API returns the status of a certification task. A token with ORG_ADMIN or CERT_ADMIN authority is required to call this API. Reviewers for this certification can also call this API.
		         * @summary Certification Task Status
		         * @param {string} id The identity campaign certification ID
		         * @param {string} taskId The certification task ID
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getIdentityCertificationTaskStatus: function (id, taskId, axiosOptions) {
		            return localVarFp.getIdentityCertificationTaskStatus(id, taskId, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API returns a list of reviewers for the certification. A token with ORG_ADMIN or CERT_ADMIN authority is required to call this API. Reviewers for this certification can also call this API.
		         * @summary List of Reviewers for certification
		         * @param {string} id The certification ID
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **name**: *eq, sw*  **email**: *eq, sw*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name, email**
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        listCertificationReviewers: function (id, limit, offset, count, filters, sorters, axiosOptions) {
		            return localVarFp.listCertificationReviewers(id, limit, offset, count, filters, sorters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API initiates a task to reassign up to 500 identities or items in an identity campaign certification to another reviewer. The `certification-tasks` API can be used to get an updated status on the task and determine when the reassignment is complete. A token with ORG_ADMIN or CERT_ADMIN authority is required to call this API. Reviewers for this certification can also call this API.
		         * @summary Reassign Certifications Asynchronously
		         * @param {string} id The identity campaign certification ID
		         * @param {ReviewReassignBeta} reviewReassignBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        submitReassignCertsAsync: function (id, reviewReassignBeta, axiosOptions) {
		            return localVarFp.submitReassignCertsAsync(id, reviewReassignBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.CertificationsBetaApiFactory = CertificationsBetaApiFactory;
		/**
		 * CertificationsBetaApi - object-oriented interface
		 * @export
		 * @class CertificationsBetaApi
		 * @extends {BaseAPI}
		 */
		var CertificationsBetaApi = /** @class */ (function (_super) {
		    __extends(CertificationsBetaApi, _super);
		    function CertificationsBetaApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * This API returns the permissions associated with an entitlement certification item based on the certification item\'s ID. A token with ORG_ADMIN or CERT_ADMIN authority is required to call this API. Reviewers for this certification can also call this API.
		     * @summary Permissions for Entitlement Certification Item
		     * @param {CertificationsBetaApiGetIdentityCertificationItemPermissionsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @deprecated
		     * @throws {RequiredError}
		     * @memberof CertificationsBetaApi
		     */
		    CertificationsBetaApi.prototype.getIdentityCertificationItemPermissions = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.CertificationsBetaApiFp)(this.configuration).getIdentityCertificationItemPermissions(requestParameters.certificationId, requestParameters.itemId, requestParameters.filters, requestParameters.limit, requestParameters.offset, requestParameters.count, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API returns the status of all pending (`QUEUED` or `IN_PROGRESS`) tasks for an identity campaign certification. A token with ORG_ADMIN or CERT_ADMIN authority is required to call this API. Reviewers for this certification can also call this API.
		     * @summary Pending Certification Tasks
		     * @param {CertificationsBetaApiGetIdentityCertificationPendingTasksRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof CertificationsBetaApi
		     */
		    CertificationsBetaApi.prototype.getIdentityCertificationPendingTasks = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.CertificationsBetaApiFp)(this.configuration).getIdentityCertificationPendingTasks(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API returns the status of a certification task. A token with ORG_ADMIN or CERT_ADMIN authority is required to call this API. Reviewers for this certification can also call this API.
		     * @summary Certification Task Status
		     * @param {CertificationsBetaApiGetIdentityCertificationTaskStatusRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof CertificationsBetaApi
		     */
		    CertificationsBetaApi.prototype.getIdentityCertificationTaskStatus = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.CertificationsBetaApiFp)(this.configuration).getIdentityCertificationTaskStatus(requestParameters.id, requestParameters.taskId, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API returns a list of reviewers for the certification. A token with ORG_ADMIN or CERT_ADMIN authority is required to call this API. Reviewers for this certification can also call this API.
		     * @summary List of Reviewers for certification
		     * @param {CertificationsBetaApiListCertificationReviewersRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @deprecated
		     * @throws {RequiredError}
		     * @memberof CertificationsBetaApi
		     */
		    CertificationsBetaApi.prototype.listCertificationReviewers = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.CertificationsBetaApiFp)(this.configuration).listCertificationReviewers(requestParameters.id, requestParameters.limit, requestParameters.offset, requestParameters.count, requestParameters.filters, requestParameters.sorters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API initiates a task to reassign up to 500 identities or items in an identity campaign certification to another reviewer. The `certification-tasks` API can be used to get an updated status on the task and determine when the reassignment is complete. A token with ORG_ADMIN or CERT_ADMIN authority is required to call this API. Reviewers for this certification can also call this API.
		     * @summary Reassign Certifications Asynchronously
		     * @param {CertificationsBetaApiSubmitReassignCertsAsyncRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @deprecated
		     * @throws {RequiredError}
		     * @memberof CertificationsBetaApi
		     */
		    CertificationsBetaApi.prototype.submitReassignCertsAsync = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.CertificationsBetaApiFp)(this.configuration).submitReassignCertsAsync(requestParameters.id, requestParameters.reviewReassignBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return CertificationsBetaApi;
		}(base_1.BaseAPI));
		exports.CertificationsBetaApi = CertificationsBetaApi;
		/**
		 * ConnectorRuleManagementBetaApi - axios parameter creator
		 * @export
		 */
		var ConnectorRuleManagementBetaApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * Creates a new connector rule. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Create Connector Rule
		         * @param {ConnectorRuleCreateRequestBeta} connectorRuleCreateRequestBeta The connector rule to create
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createConnectorRule: function (connectorRuleCreateRequestBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'connectorRuleCreateRequestBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('createConnectorRule', 'connectorRuleCreateRequestBeta', connectorRuleCreateRequestBeta);
		                            localVarPath = "/connector-rules";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(connectorRuleCreateRequestBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Deletes the connector rule specified by the given ID. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Delete a Connector-Rule
		         * @param {string} id ID of the connector rule to delete
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteConnectorRule: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('deleteConnectorRule', 'id', id);
		                            localVarPath = "/connector-rules/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'DELETE' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Returns the connector rule specified by ID. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Connector-Rule by ID
		         * @param {string} id ID of the connector rule to retrieve
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getConnectorRule: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getConnectorRule', 'id', id);
		                            localVarPath = "/connector-rules/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Returns the list of connector rules. A token with ORG_ADMIN authority is required to call this API.
		         * @summary List Connector Rules
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getConnectorRuleList: function (axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/connector-rules";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Updates an existing connector rule with the one provided in the request body. Note that the fields \'id\', \'name\', and \'type\' are immutable. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Update a Connector Rule
		         * @param {string} id ID of the connector rule to update
		         * @param {ConnectorRuleUpdateRequestBeta} [connectorRuleUpdateRequestBeta] The connector rule with updated data
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateConnectorRule: function (id, connectorRuleUpdateRequestBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('updateConnectorRule', 'id', id);
		                            localVarPath = "/connector-rules/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PUT' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(connectorRuleUpdateRequestBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Returns a list of issues within the code to fix, if any. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Validate Connector Rule
		         * @param {SourceCodeBeta} sourceCodeBeta The code to validate
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        validateConnectorRule: function (sourceCodeBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'sourceCodeBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('validateConnectorRule', 'sourceCodeBeta', sourceCodeBeta);
		                            localVarPath = "/connector-rules/validate";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(sourceCodeBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.ConnectorRuleManagementBetaApiAxiosParamCreator = ConnectorRuleManagementBetaApiAxiosParamCreator;
		/**
		 * ConnectorRuleManagementBetaApi - functional programming interface
		 * @export
		 */
		var ConnectorRuleManagementBetaApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.ConnectorRuleManagementBetaApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * Creates a new connector rule. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Create Connector Rule
		         * @param {ConnectorRuleCreateRequestBeta} connectorRuleCreateRequestBeta The connector rule to create
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createConnectorRule: function (connectorRuleCreateRequestBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.createConnectorRule(connectorRuleCreateRequestBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Deletes the connector rule specified by the given ID. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Delete a Connector-Rule
		         * @param {string} id ID of the connector rule to delete
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteConnectorRule: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.deleteConnectorRule(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Returns the connector rule specified by ID. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Connector-Rule by ID
		         * @param {string} id ID of the connector rule to retrieve
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getConnectorRule: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getConnectorRule(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Returns the list of connector rules. A token with ORG_ADMIN authority is required to call this API.
		         * @summary List Connector Rules
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getConnectorRuleList: function (axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getConnectorRuleList(axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Updates an existing connector rule with the one provided in the request body. Note that the fields \'id\', \'name\', and \'type\' are immutable. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Update a Connector Rule
		         * @param {string} id ID of the connector rule to update
		         * @param {ConnectorRuleUpdateRequestBeta} [connectorRuleUpdateRequestBeta] The connector rule with updated data
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateConnectorRule: function (id, connectorRuleUpdateRequestBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.updateConnectorRule(id, connectorRuleUpdateRequestBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Returns a list of issues within the code to fix, if any. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Validate Connector Rule
		         * @param {SourceCodeBeta} sourceCodeBeta The code to validate
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        validateConnectorRule: function (sourceCodeBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.validateConnectorRule(sourceCodeBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.ConnectorRuleManagementBetaApiFp = ConnectorRuleManagementBetaApiFp;
		/**
		 * ConnectorRuleManagementBetaApi - factory interface
		 * @export
		 */
		var ConnectorRuleManagementBetaApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.ConnectorRuleManagementBetaApiFp)(configuration);
		    return {
		        /**
		         * Creates a new connector rule. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Create Connector Rule
		         * @param {ConnectorRuleCreateRequestBeta} connectorRuleCreateRequestBeta The connector rule to create
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createConnectorRule: function (connectorRuleCreateRequestBeta, axiosOptions) {
		            return localVarFp.createConnectorRule(connectorRuleCreateRequestBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Deletes the connector rule specified by the given ID. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Delete a Connector-Rule
		         * @param {string} id ID of the connector rule to delete
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteConnectorRule: function (id, axiosOptions) {
		            return localVarFp.deleteConnectorRule(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Returns the connector rule specified by ID. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Connector-Rule by ID
		         * @param {string} id ID of the connector rule to retrieve
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getConnectorRule: function (id, axiosOptions) {
		            return localVarFp.getConnectorRule(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Returns the list of connector rules. A token with ORG_ADMIN authority is required to call this API.
		         * @summary List Connector Rules
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getConnectorRuleList: function (axiosOptions) {
		            return localVarFp.getConnectorRuleList(axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Updates an existing connector rule with the one provided in the request body. Note that the fields \'id\', \'name\', and \'type\' are immutable. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Update a Connector Rule
		         * @param {string} id ID of the connector rule to update
		         * @param {ConnectorRuleUpdateRequestBeta} [connectorRuleUpdateRequestBeta] The connector rule with updated data
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateConnectorRule: function (id, connectorRuleUpdateRequestBeta, axiosOptions) {
		            return localVarFp.updateConnectorRule(id, connectorRuleUpdateRequestBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Returns a list of issues within the code to fix, if any. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Validate Connector Rule
		         * @param {SourceCodeBeta} sourceCodeBeta The code to validate
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        validateConnectorRule: function (sourceCodeBeta, axiosOptions) {
		            return localVarFp.validateConnectorRule(sourceCodeBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.ConnectorRuleManagementBetaApiFactory = ConnectorRuleManagementBetaApiFactory;
		/**
		 * ConnectorRuleManagementBetaApi - object-oriented interface
		 * @export
		 * @class ConnectorRuleManagementBetaApi
		 * @extends {BaseAPI}
		 */
		var ConnectorRuleManagementBetaApi = /** @class */ (function (_super) {
		    __extends(ConnectorRuleManagementBetaApi, _super);
		    function ConnectorRuleManagementBetaApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * Creates a new connector rule. A token with ORG_ADMIN authority is required to call this API.
		     * @summary Create Connector Rule
		     * @param {ConnectorRuleManagementBetaApiCreateConnectorRuleRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof ConnectorRuleManagementBetaApi
		     */
		    ConnectorRuleManagementBetaApi.prototype.createConnectorRule = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.ConnectorRuleManagementBetaApiFp)(this.configuration).createConnectorRule(requestParameters.connectorRuleCreateRequestBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Deletes the connector rule specified by the given ID. A token with ORG_ADMIN authority is required to call this API.
		     * @summary Delete a Connector-Rule
		     * @param {ConnectorRuleManagementBetaApiDeleteConnectorRuleRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof ConnectorRuleManagementBetaApi
		     */
		    ConnectorRuleManagementBetaApi.prototype.deleteConnectorRule = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.ConnectorRuleManagementBetaApiFp)(this.configuration).deleteConnectorRule(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Returns the connector rule specified by ID. A token with ORG_ADMIN authority is required to call this API.
		     * @summary Connector-Rule by ID
		     * @param {ConnectorRuleManagementBetaApiGetConnectorRuleRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof ConnectorRuleManagementBetaApi
		     */
		    ConnectorRuleManagementBetaApi.prototype.getConnectorRule = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.ConnectorRuleManagementBetaApiFp)(this.configuration).getConnectorRule(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Returns the list of connector rules. A token with ORG_ADMIN authority is required to call this API.
		     * @summary List Connector Rules
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof ConnectorRuleManagementBetaApi
		     */
		    ConnectorRuleManagementBetaApi.prototype.getConnectorRuleList = function (axiosOptions) {
		        var _this = this;
		        return (0, exports.ConnectorRuleManagementBetaApiFp)(this.configuration).getConnectorRuleList(axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Updates an existing connector rule with the one provided in the request body. Note that the fields \'id\', \'name\', and \'type\' are immutable. A token with ORG_ADMIN authority is required to call this API.
		     * @summary Update a Connector Rule
		     * @param {ConnectorRuleManagementBetaApiUpdateConnectorRuleRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof ConnectorRuleManagementBetaApi
		     */
		    ConnectorRuleManagementBetaApi.prototype.updateConnectorRule = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.ConnectorRuleManagementBetaApiFp)(this.configuration).updateConnectorRule(requestParameters.id, requestParameters.connectorRuleUpdateRequestBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Returns a list of issues within the code to fix, if any. A token with ORG_ADMIN authority is required to call this API.
		     * @summary Validate Connector Rule
		     * @param {ConnectorRuleManagementBetaApiValidateConnectorRuleRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof ConnectorRuleManagementBetaApi
		     */
		    ConnectorRuleManagementBetaApi.prototype.validateConnectorRule = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.ConnectorRuleManagementBetaApiFp)(this.configuration).validateConnectorRule(requestParameters.sourceCodeBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return ConnectorRuleManagementBetaApi;
		}(base_1.BaseAPI));
		exports.ConnectorRuleManagementBetaApi = ConnectorRuleManagementBetaApi;
		/**
		 * ConnectorsBetaApi - axios parameter creator
		 * @export
		 */
		var ConnectorsBetaApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * Fetches list of connectors that have \'RELEASED\' status using filtering and pagination. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Gets connector list
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **name**: *sw*  **type**: *eq*  **directConnect**: *eq*  **category**: *eq*  **features**: *ca*
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {'de' | 'false' | 'fi' | 'sv' | 'ru' | 'pt' | 'ko' | 'zh-TW' | 'en' | 'it' | 'fr' | 'zh-CN' | 'hu' | 'es' | 'cs' | 'ja' | 'pl' | 'da' | 'nl'} [locale] The locale to apply to the config. If no viable locale is given, it will default to \&quot;en\&quot;
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getConnectorList: function (filters, limit, offset, count, locale, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/connectors";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (locale !== undefined) {
		                                localVarQueryParameter['locale'] = locale;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.ConnectorsBetaApiAxiosParamCreator = ConnectorsBetaApiAxiosParamCreator;
		/**
		 * ConnectorsBetaApi - functional programming interface
		 * @export
		 */
		var ConnectorsBetaApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.ConnectorsBetaApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * Fetches list of connectors that have \'RELEASED\' status using filtering and pagination. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Gets connector list
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **name**: *sw*  **type**: *eq*  **directConnect**: *eq*  **category**: *eq*  **features**: *ca*
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {'de' | 'false' | 'fi' | 'sv' | 'ru' | 'pt' | 'ko' | 'zh-TW' | 'en' | 'it' | 'fr' | 'zh-CN' | 'hu' | 'es' | 'cs' | 'ja' | 'pl' | 'da' | 'nl'} [locale] The locale to apply to the config. If no viable locale is given, it will default to \&quot;en\&quot;
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getConnectorList: function (filters, limit, offset, count, locale, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getConnectorList(filters, limit, offset, count, locale, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.ConnectorsBetaApiFp = ConnectorsBetaApiFp;
		/**
		 * ConnectorsBetaApi - factory interface
		 * @export
		 */
		var ConnectorsBetaApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.ConnectorsBetaApiFp)(configuration);
		    return {
		        /**
		         * Fetches list of connectors that have \'RELEASED\' status using filtering and pagination. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Gets connector list
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **name**: *sw*  **type**: *eq*  **directConnect**: *eq*  **category**: *eq*  **features**: *ca*
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {'de' | 'false' | 'fi' | 'sv' | 'ru' | 'pt' | 'ko' | 'zh-TW' | 'en' | 'it' | 'fr' | 'zh-CN' | 'hu' | 'es' | 'cs' | 'ja' | 'pl' | 'da' | 'nl'} [locale] The locale to apply to the config. If no viable locale is given, it will default to \&quot;en\&quot;
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getConnectorList: function (filters, limit, offset, count, locale, axiosOptions) {
		            return localVarFp.getConnectorList(filters, limit, offset, count, locale, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.ConnectorsBetaApiFactory = ConnectorsBetaApiFactory;
		/**
		 * ConnectorsBetaApi - object-oriented interface
		 * @export
		 * @class ConnectorsBetaApi
		 * @extends {BaseAPI}
		 */
		var ConnectorsBetaApi = /** @class */ (function (_super) {
		    __extends(ConnectorsBetaApi, _super);
		    function ConnectorsBetaApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * Fetches list of connectors that have \'RELEASED\' status using filtering and pagination. A token with ORG_ADMIN authority is required to call this API.
		     * @summary Gets connector list
		     * @param {ConnectorsBetaApiGetConnectorListRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof ConnectorsBetaApi
		     */
		    ConnectorsBetaApi.prototype.getConnectorList = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.ConnectorsBetaApiFp)(this.configuration).getConnectorList(requestParameters.filters, requestParameters.limit, requestParameters.offset, requestParameters.count, requestParameters.locale, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return ConnectorsBetaApi;
		}(base_1.BaseAPI));
		exports.ConnectorsBetaApi = ConnectorsBetaApi;
		/**
		 * CustomFormsBetaApi - axios parameter creator
		 * @export
		 */
		var CustomFormsBetaApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         *
		         * @summary Creates a form definition.
		         * @param {CreateFormDefinitionRequestBeta} [body] Body is the request payload to create form definition request
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createFormDefinition: function (body, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/form-definitions";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(body, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         *
		         * @summary Generate JSON Schema dynamically.
		         * @param {FormDefinitionDynamicSchemaRequestBeta} [body] Body is the request payload to create a form definition dynamic schema
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createFormDefinitionDynamicSchema: function (body, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/form-definitions/forms-action-dynamic-schema";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(body, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Parameter `{formDefinitionID}` should match a form definition ID.
		         * @summary Upload new form definition file.
		         * @param {string} formDefinitionID FormDefinitionID  String specifying FormDefinitionID
		         * @param {any} file File specifying the multipart
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createFormDefinitionFileRequest: function (formDefinitionID, file, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, localVarFormParams, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'formDefinitionID' is not null or undefined
		                            (0, common_1.assertParamExists)('createFormDefinitionFileRequest', 'formDefinitionID', formDefinitionID);
		                            // verify required parameter 'file' is not null or undefined
		                            (0, common_1.assertParamExists)('createFormDefinitionFileRequest', 'file', file);
		                            localVarPath = "/form-definitions/{formDefinitionID}/upload"
		                                .replace("{".concat("formDefinitionID", "}"), encodeURIComponent(String(formDefinitionID)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            localVarFormParams = new ((configuration && configuration.formDataCtor) || FormData)();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (file !== undefined) {
		                                localVarFormParams.append('file', file);
		                            }
		                            localVarHeaderParameter['Content-Type'] = 'multipart/form-data';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = localVarFormParams;
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         *
		         * @summary Creates a form instance.
		         * @param {CreateFormInstanceRequestBeta} [body] Body is the request payload to create a form instance
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createFormInstance: function (body, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/form-instances";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(body, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Parameter `{formDefinitionID}` should match a form definition ID.
		         * @summary Deletes a form definition.
		         * @param {string} formDefinitionID Form definition ID
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteFormDefinition: function (formDefinitionID, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'formDefinitionID' is not null or undefined
		                            (0, common_1.assertParamExists)('deleteFormDefinition', 'formDefinitionID', formDefinitionID);
		                            localVarPath = "/form-definitions/{formDefinitionID}"
		                                .replace("{".concat("formDefinitionID", "}"), encodeURIComponent(String(formDefinitionID)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'DELETE' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * No parameters required.
		         * @summary List form definitions by tenant.
		         * @param {number} [offset] Offset  Integer specifying the offset of the first result from the beginning of the collection. The standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#paginating-results). The offset value is record-based, not page-based, and the index starts at 0.
		         * @param {number} [limit] Limit  Integer specifying the maximum number of records to return in a single API call. The standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#paginating-results). If it is not specified, a default limit is used.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **name**: *eq, gt, sw, in*  **description**: *eq, gt, sw, in*  **created**: *eq, gt, sw, in*  **modified**: *eq, gt, sw, in*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name, description, created, modified**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        exportFormDefinitionsByTenant: function (offset, limit, filters, sorters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/form-definitions/export";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         *
		         * @summary Download definition file by fileId.
		         * @param {string} formDefinitionID FormDefinitionID  Form definition ID
		         * @param {string} fileID FileID  String specifying the hashed name of the uploaded file we are retrieving.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getFileFromS3: function (formDefinitionID, fileID, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'formDefinitionID' is not null or undefined
		                            (0, common_1.assertParamExists)('getFileFromS3', 'formDefinitionID', formDefinitionID);
		                            // verify required parameter 'fileID' is not null or undefined
		                            (0, common_1.assertParamExists)('getFileFromS3', 'fileID', fileID);
		                            localVarPath = "/form-definitions/{formDefinitionID}/file/{fileID}"
		                                .replace("{".concat("formDefinitionID", "}"), encodeURIComponent(String(formDefinitionID)))
		                                .replace("{".concat("fileID", "}"), encodeURIComponent(String(fileID)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Parameter `{formDefinitionID}` should match a form definition ID.
		         * @summary Return a form definition.
		         * @param {string} formDefinitionID Form definition ID
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getFormDefinitionByKey: function (formDefinitionID, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'formDefinitionID' is not null or undefined
		                            (0, common_1.assertParamExists)('getFormDefinitionByKey', 'formDefinitionID', formDefinitionID);
		                            localVarPath = "/form-definitions/{formDefinitionID}"
		                                .replace("{".concat("formDefinitionID", "}"), encodeURIComponent(String(formDefinitionID)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Parameter `{formInstanceID}` should match a form instance ID.
		         * @summary Returns a form instance.
		         * @param {string} formInstanceID Form instance ID
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getFormInstanceByKey: function (formInstanceID, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'formInstanceID' is not null or undefined
		                            (0, common_1.assertParamExists)('getFormInstanceByKey', 'formInstanceID', formInstanceID);
		                            localVarPath = "/form-instances/{formInstanceID}"
		                                .replace("{".concat("formInstanceID", "}"), encodeURIComponent(String(formInstanceID)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         *
		         * @summary Download instance file by fileId.
		         * @param {string} formInstanceID FormInstanceID  Form instance ID
		         * @param {string} fileID FileID  String specifying the hashed name of the uploaded file we are retrieving.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getFormInstanceFile: function (formInstanceID, fileID, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'formInstanceID' is not null or undefined
		                            (0, common_1.assertParamExists)('getFormInstanceFile', 'formInstanceID', formInstanceID);
		                            // verify required parameter 'fileID' is not null or undefined
		                            (0, common_1.assertParamExists)('getFormInstanceFile', 'fileID', fileID);
		                            localVarPath = "/form-instances/{formInstanceID}/file/{fileID}"
		                                .replace("{".concat("formInstanceID", "}"), encodeURIComponent(String(formInstanceID)))
		                                .replace("{".concat("fileID", "}"), encodeURIComponent(String(fileID)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         *
		         * @summary Import form definitions from export.
		         * @param {Array<ExportFormDefinitionsByTenant200ResponseInnerBeta>} [body] Body is the request payload to import form definitions
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        importFormDefinitions: function (body, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/form-definitions/import";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(body, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Parameter `{formDefinitionID}` should match a form definition ID.
		         * @summary Patch a form definition.
		         * @param {string} formDefinitionID Form definition ID
		         * @param {Array<{ [key: string]: object; }>} [body] Body is the request payload to patch a form definition, check: https://jsonpatch.com
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchFormDefinition: function (formDefinitionID, body, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'formDefinitionID' is not null or undefined
		                            (0, common_1.assertParamExists)('patchFormDefinition', 'formDefinitionID', formDefinitionID);
		                            localVarPath = "/form-definitions/{formDefinitionID}"
		                                .replace("{".concat("formDefinitionID", "}"), encodeURIComponent(String(formDefinitionID)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PATCH' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(body, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Parameter `{formInstanceID}` should match a form instance ID.
		         * @summary Patch a form instance.
		         * @param {string} formInstanceID Form instance ID
		         * @param {Array<{ [key: string]: object; }>} [body] Body is the request payload to patch a form instance, check: https://jsonpatch.com
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchFormInstance: function (formInstanceID, body, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'formInstanceID' is not null or undefined
		                            (0, common_1.assertParamExists)('patchFormInstance', 'formInstanceID', formInstanceID);
		                            localVarPath = "/form-instances/{formInstanceID}"
		                                .replace("{".concat("formInstanceID", "}"), encodeURIComponent(String(formInstanceID)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PATCH' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(body, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * No parameters required.
		         * @summary Export form definitions by tenant.
		         * @param {number} [offset] Offset  Integer specifying the offset of the first result from the beginning of the collection. The standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#paginating-results). The offset value is record-based, not page-based, and the index starts at 0.
		         * @param {number} [limit] Limit  Integer specifying the maximum number of records to return in a single API call. The standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#paginating-results). If it is not specified, a default limit is used.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **name**: *eq, gt, sw, in*  **description**: *eq, gt, sw, in*  **created**: *eq, gt, sw, in*  **modified**: *eq, gt, sw, in*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name, description, created, modified**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        searchFormDefinitionsByTenant: function (offset, limit, filters, sorters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/form-definitions";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Parameter `{formInstanceID}` should match a form instance ID. Parameter `{formElementID}` should match a form element ID at the data source configuration.
		         * @summary Retrieves dynamic data by element.
		         * @param {string} formInstanceID Form instance ID
		         * @param {string} formElementID Form element ID
		         * @param {number} [limit] Limit  Integer specifying the maximum number of records to return in a single API call. The standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#paginating-results). If it is not specified, a default limit is used.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **value**: *eq, ne, in*  **label**: *eq, ne, in*  **subLabel**: *eq, ne, in*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        searchFormElementDataByElementID: function (formInstanceID, formElementID, limit, filters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'formInstanceID' is not null or undefined
		                            (0, common_1.assertParamExists)('searchFormElementDataByElementID', 'formInstanceID', formInstanceID);
		                            // verify required parameter 'formElementID' is not null or undefined
		                            (0, common_1.assertParamExists)('searchFormElementDataByElementID', 'formElementID', formElementID);
		                            localVarPath = "/form-instances/{formInstanceID}/data-source/{formElementID}"
		                                .replace("{".concat("formInstanceID", "}"), encodeURIComponent(String(formInstanceID)))
		                                .replace("{".concat("formElementID", "}"), encodeURIComponent(String(formElementID)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * No parameters required.
		         * @summary List form instances by tenant.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        searchFormInstancesByTenant: function (axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/form-instances";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * No parameters required.
		         * @summary List predefined select options.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        searchPreDefinedSelectOptions: function (axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/form-definitions/predefined-select-options";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         *
		         * @summary Preview form definition data source.
		         * @param {string} formDefinitionID Form definition ID
		         * @param {number} [limit] Limit  Integer specifying the maximum number of records to return in a single API call. The standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#paginating-results). If it is not specified, a default limit is used.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **value**: *eq, gt, sw, in*  **label**: *eq, gt, sw, in*  **subLabel**: *eq, gt, sw, in*
		         * @param {string} [query] Query  String specifying to query against
		         * @param {FormElementPreviewRequestBeta} [formElementPreviewRequestBeta] Body is the request payload to create a form definition dynamic schema
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        showPreviewDataSource: function (formDefinitionID, limit, filters, query, formElementPreviewRequestBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'formDefinitionID' is not null or undefined
		                            (0, common_1.assertParamExists)('showPreviewDataSource', 'formDefinitionID', formDefinitionID);
		                            localVarPath = "/form-definitions/{formDefinitionID}/data-source"
		                                .replace("{".concat("formDefinitionID", "}"), encodeURIComponent(String(formDefinitionID)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            if (query !== undefined) {
		                                localVarQueryParameter['query'] = query;
		                            }
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(formElementPreviewRequestBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.CustomFormsBetaApiAxiosParamCreator = CustomFormsBetaApiAxiosParamCreator;
		/**
		 * CustomFormsBetaApi - functional programming interface
		 * @export
		 */
		var CustomFormsBetaApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.CustomFormsBetaApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         *
		         * @summary Creates a form definition.
		         * @param {CreateFormDefinitionRequestBeta} [body] Body is the request payload to create form definition request
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createFormDefinition: function (body, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.createFormDefinition(body, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         *
		         * @summary Generate JSON Schema dynamically.
		         * @param {FormDefinitionDynamicSchemaRequestBeta} [body] Body is the request payload to create a form definition dynamic schema
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createFormDefinitionDynamicSchema: function (body, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.createFormDefinitionDynamicSchema(body, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Parameter `{formDefinitionID}` should match a form definition ID.
		         * @summary Upload new form definition file.
		         * @param {string} formDefinitionID FormDefinitionID  String specifying FormDefinitionID
		         * @param {any} file File specifying the multipart
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createFormDefinitionFileRequest: function (formDefinitionID, file, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.createFormDefinitionFileRequest(formDefinitionID, file, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         *
		         * @summary Creates a form instance.
		         * @param {CreateFormInstanceRequestBeta} [body] Body is the request payload to create a form instance
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createFormInstance: function (body, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.createFormInstance(body, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Parameter `{formDefinitionID}` should match a form definition ID.
		         * @summary Deletes a form definition.
		         * @param {string} formDefinitionID Form definition ID
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteFormDefinition: function (formDefinitionID, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.deleteFormDefinition(formDefinitionID, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * No parameters required.
		         * @summary List form definitions by tenant.
		         * @param {number} [offset] Offset  Integer specifying the offset of the first result from the beginning of the collection. The standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#paginating-results). The offset value is record-based, not page-based, and the index starts at 0.
		         * @param {number} [limit] Limit  Integer specifying the maximum number of records to return in a single API call. The standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#paginating-results). If it is not specified, a default limit is used.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **name**: *eq, gt, sw, in*  **description**: *eq, gt, sw, in*  **created**: *eq, gt, sw, in*  **modified**: *eq, gt, sw, in*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name, description, created, modified**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        exportFormDefinitionsByTenant: function (offset, limit, filters, sorters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.exportFormDefinitionsByTenant(offset, limit, filters, sorters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         *
		         * @summary Download definition file by fileId.
		         * @param {string} formDefinitionID FormDefinitionID  Form definition ID
		         * @param {string} fileID FileID  String specifying the hashed name of the uploaded file we are retrieving.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getFileFromS3: function (formDefinitionID, fileID, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getFileFromS3(formDefinitionID, fileID, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Parameter `{formDefinitionID}` should match a form definition ID.
		         * @summary Return a form definition.
		         * @param {string} formDefinitionID Form definition ID
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getFormDefinitionByKey: function (formDefinitionID, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getFormDefinitionByKey(formDefinitionID, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Parameter `{formInstanceID}` should match a form instance ID.
		         * @summary Returns a form instance.
		         * @param {string} formInstanceID Form instance ID
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getFormInstanceByKey: function (formInstanceID, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getFormInstanceByKey(formInstanceID, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         *
		         * @summary Download instance file by fileId.
		         * @param {string} formInstanceID FormInstanceID  Form instance ID
		         * @param {string} fileID FileID  String specifying the hashed name of the uploaded file we are retrieving.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getFormInstanceFile: function (formInstanceID, fileID, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getFormInstanceFile(formInstanceID, fileID, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         *
		         * @summary Import form definitions from export.
		         * @param {Array<ExportFormDefinitionsByTenant200ResponseInnerBeta>} [body] Body is the request payload to import form definitions
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        importFormDefinitions: function (body, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.importFormDefinitions(body, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Parameter `{formDefinitionID}` should match a form definition ID.
		         * @summary Patch a form definition.
		         * @param {string} formDefinitionID Form definition ID
		         * @param {Array<{ [key: string]: object; }>} [body] Body is the request payload to patch a form definition, check: https://jsonpatch.com
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchFormDefinition: function (formDefinitionID, body, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.patchFormDefinition(formDefinitionID, body, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Parameter `{formInstanceID}` should match a form instance ID.
		         * @summary Patch a form instance.
		         * @param {string} formInstanceID Form instance ID
		         * @param {Array<{ [key: string]: object; }>} [body] Body is the request payload to patch a form instance, check: https://jsonpatch.com
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchFormInstance: function (formInstanceID, body, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.patchFormInstance(formInstanceID, body, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * No parameters required.
		         * @summary Export form definitions by tenant.
		         * @param {number} [offset] Offset  Integer specifying the offset of the first result from the beginning of the collection. The standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#paginating-results). The offset value is record-based, not page-based, and the index starts at 0.
		         * @param {number} [limit] Limit  Integer specifying the maximum number of records to return in a single API call. The standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#paginating-results). If it is not specified, a default limit is used.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **name**: *eq, gt, sw, in*  **description**: *eq, gt, sw, in*  **created**: *eq, gt, sw, in*  **modified**: *eq, gt, sw, in*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name, description, created, modified**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        searchFormDefinitionsByTenant: function (offset, limit, filters, sorters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.searchFormDefinitionsByTenant(offset, limit, filters, sorters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Parameter `{formInstanceID}` should match a form instance ID. Parameter `{formElementID}` should match a form element ID at the data source configuration.
		         * @summary Retrieves dynamic data by element.
		         * @param {string} formInstanceID Form instance ID
		         * @param {string} formElementID Form element ID
		         * @param {number} [limit] Limit  Integer specifying the maximum number of records to return in a single API call. The standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#paginating-results). If it is not specified, a default limit is used.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **value**: *eq, ne, in*  **label**: *eq, ne, in*  **subLabel**: *eq, ne, in*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        searchFormElementDataByElementID: function (formInstanceID, formElementID, limit, filters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.searchFormElementDataByElementID(formInstanceID, formElementID, limit, filters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * No parameters required.
		         * @summary List form instances by tenant.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        searchFormInstancesByTenant: function (axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.searchFormInstancesByTenant(axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * No parameters required.
		         * @summary List predefined select options.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        searchPreDefinedSelectOptions: function (axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.searchPreDefinedSelectOptions(axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         *
		         * @summary Preview form definition data source.
		         * @param {string} formDefinitionID Form definition ID
		         * @param {number} [limit] Limit  Integer specifying the maximum number of records to return in a single API call. The standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#paginating-results). If it is not specified, a default limit is used.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **value**: *eq, gt, sw, in*  **label**: *eq, gt, sw, in*  **subLabel**: *eq, gt, sw, in*
		         * @param {string} [query] Query  String specifying to query against
		         * @param {FormElementPreviewRequestBeta} [formElementPreviewRequestBeta] Body is the request payload to create a form definition dynamic schema
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        showPreviewDataSource: function (formDefinitionID, limit, filters, query, formElementPreviewRequestBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.showPreviewDataSource(formDefinitionID, limit, filters, query, formElementPreviewRequestBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.CustomFormsBetaApiFp = CustomFormsBetaApiFp;
		/**
		 * CustomFormsBetaApi - factory interface
		 * @export
		 */
		var CustomFormsBetaApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.CustomFormsBetaApiFp)(configuration);
		    return {
		        /**
		         *
		         * @summary Creates a form definition.
		         * @param {CreateFormDefinitionRequestBeta} [body] Body is the request payload to create form definition request
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createFormDefinition: function (body, axiosOptions) {
		            return localVarFp.createFormDefinition(body, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         *
		         * @summary Generate JSON Schema dynamically.
		         * @param {FormDefinitionDynamicSchemaRequestBeta} [body] Body is the request payload to create a form definition dynamic schema
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createFormDefinitionDynamicSchema: function (body, axiosOptions) {
		            return localVarFp.createFormDefinitionDynamicSchema(body, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Parameter `{formDefinitionID}` should match a form definition ID.
		         * @summary Upload new form definition file.
		         * @param {string} formDefinitionID FormDefinitionID  String specifying FormDefinitionID
		         * @param {any} file File specifying the multipart
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createFormDefinitionFileRequest: function (formDefinitionID, file, axiosOptions) {
		            return localVarFp.createFormDefinitionFileRequest(formDefinitionID, file, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         *
		         * @summary Creates a form instance.
		         * @param {CreateFormInstanceRequestBeta} [body] Body is the request payload to create a form instance
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createFormInstance: function (body, axiosOptions) {
		            return localVarFp.createFormInstance(body, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Parameter `{formDefinitionID}` should match a form definition ID.
		         * @summary Deletes a form definition.
		         * @param {string} formDefinitionID Form definition ID
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteFormDefinition: function (formDefinitionID, axiosOptions) {
		            return localVarFp.deleteFormDefinition(formDefinitionID, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * No parameters required.
		         * @summary List form definitions by tenant.
		         * @param {number} [offset] Offset  Integer specifying the offset of the first result from the beginning of the collection. The standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#paginating-results). The offset value is record-based, not page-based, and the index starts at 0.
		         * @param {number} [limit] Limit  Integer specifying the maximum number of records to return in a single API call. The standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#paginating-results). If it is not specified, a default limit is used.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **name**: *eq, gt, sw, in*  **description**: *eq, gt, sw, in*  **created**: *eq, gt, sw, in*  **modified**: *eq, gt, sw, in*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name, description, created, modified**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        exportFormDefinitionsByTenant: function (offset, limit, filters, sorters, axiosOptions) {
		            return localVarFp.exportFormDefinitionsByTenant(offset, limit, filters, sorters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         *
		         * @summary Download definition file by fileId.
		         * @param {string} formDefinitionID FormDefinitionID  Form definition ID
		         * @param {string} fileID FileID  String specifying the hashed name of the uploaded file we are retrieving.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getFileFromS3: function (formDefinitionID, fileID, axiosOptions) {
		            return localVarFp.getFileFromS3(formDefinitionID, fileID, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Parameter `{formDefinitionID}` should match a form definition ID.
		         * @summary Return a form definition.
		         * @param {string} formDefinitionID Form definition ID
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getFormDefinitionByKey: function (formDefinitionID, axiosOptions) {
		            return localVarFp.getFormDefinitionByKey(formDefinitionID, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Parameter `{formInstanceID}` should match a form instance ID.
		         * @summary Returns a form instance.
		         * @param {string} formInstanceID Form instance ID
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getFormInstanceByKey: function (formInstanceID, axiosOptions) {
		            return localVarFp.getFormInstanceByKey(formInstanceID, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         *
		         * @summary Download instance file by fileId.
		         * @param {string} formInstanceID FormInstanceID  Form instance ID
		         * @param {string} fileID FileID  String specifying the hashed name of the uploaded file we are retrieving.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getFormInstanceFile: function (formInstanceID, fileID, axiosOptions) {
		            return localVarFp.getFormInstanceFile(formInstanceID, fileID, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         *
		         * @summary Import form definitions from export.
		         * @param {Array<ExportFormDefinitionsByTenant200ResponseInnerBeta>} [body] Body is the request payload to import form definitions
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        importFormDefinitions: function (body, axiosOptions) {
		            return localVarFp.importFormDefinitions(body, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Parameter `{formDefinitionID}` should match a form definition ID.
		         * @summary Patch a form definition.
		         * @param {string} formDefinitionID Form definition ID
		         * @param {Array<{ [key: string]: object; }>} [body] Body is the request payload to patch a form definition, check: https://jsonpatch.com
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchFormDefinition: function (formDefinitionID, body, axiosOptions) {
		            return localVarFp.patchFormDefinition(formDefinitionID, body, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Parameter `{formInstanceID}` should match a form instance ID.
		         * @summary Patch a form instance.
		         * @param {string} formInstanceID Form instance ID
		         * @param {Array<{ [key: string]: object; }>} [body] Body is the request payload to patch a form instance, check: https://jsonpatch.com
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchFormInstance: function (formInstanceID, body, axiosOptions) {
		            return localVarFp.patchFormInstance(formInstanceID, body, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * No parameters required.
		         * @summary Export form definitions by tenant.
		         * @param {number} [offset] Offset  Integer specifying the offset of the first result from the beginning of the collection. The standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#paginating-results). The offset value is record-based, not page-based, and the index starts at 0.
		         * @param {number} [limit] Limit  Integer specifying the maximum number of records to return in a single API call. The standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#paginating-results). If it is not specified, a default limit is used.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **name**: *eq, gt, sw, in*  **description**: *eq, gt, sw, in*  **created**: *eq, gt, sw, in*  **modified**: *eq, gt, sw, in*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name, description, created, modified**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        searchFormDefinitionsByTenant: function (offset, limit, filters, sorters, axiosOptions) {
		            return localVarFp.searchFormDefinitionsByTenant(offset, limit, filters, sorters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Parameter `{formInstanceID}` should match a form instance ID. Parameter `{formElementID}` should match a form element ID at the data source configuration.
		         * @summary Retrieves dynamic data by element.
		         * @param {string} formInstanceID Form instance ID
		         * @param {string} formElementID Form element ID
		         * @param {number} [limit] Limit  Integer specifying the maximum number of records to return in a single API call. The standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#paginating-results). If it is not specified, a default limit is used.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **value**: *eq, ne, in*  **label**: *eq, ne, in*  **subLabel**: *eq, ne, in*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        searchFormElementDataByElementID: function (formInstanceID, formElementID, limit, filters, axiosOptions) {
		            return localVarFp.searchFormElementDataByElementID(formInstanceID, formElementID, limit, filters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * No parameters required.
		         * @summary List form instances by tenant.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        searchFormInstancesByTenant: function (axiosOptions) {
		            return localVarFp.searchFormInstancesByTenant(axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * No parameters required.
		         * @summary List predefined select options.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        searchPreDefinedSelectOptions: function (axiosOptions) {
		            return localVarFp.searchPreDefinedSelectOptions(axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         *
		         * @summary Preview form definition data source.
		         * @param {string} formDefinitionID Form definition ID
		         * @param {number} [limit] Limit  Integer specifying the maximum number of records to return in a single API call. The standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#paginating-results). If it is not specified, a default limit is used.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **value**: *eq, gt, sw, in*  **label**: *eq, gt, sw, in*  **subLabel**: *eq, gt, sw, in*
		         * @param {string} [query] Query  String specifying to query against
		         * @param {FormElementPreviewRequestBeta} [formElementPreviewRequestBeta] Body is the request payload to create a form definition dynamic schema
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        showPreviewDataSource: function (formDefinitionID, limit, filters, query, formElementPreviewRequestBeta, axiosOptions) {
		            return localVarFp.showPreviewDataSource(formDefinitionID, limit, filters, query, formElementPreviewRequestBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.CustomFormsBetaApiFactory = CustomFormsBetaApiFactory;
		/**
		 * CustomFormsBetaApi - object-oriented interface
		 * @export
		 * @class CustomFormsBetaApi
		 * @extends {BaseAPI}
		 */
		var CustomFormsBetaApi = /** @class */ (function (_super) {
		    __extends(CustomFormsBetaApi, _super);
		    function CustomFormsBetaApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     *
		     * @summary Creates a form definition.
		     * @param {CustomFormsBetaApiCreateFormDefinitionRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof CustomFormsBetaApi
		     */
		    CustomFormsBetaApi.prototype.createFormDefinition = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.CustomFormsBetaApiFp)(this.configuration).createFormDefinition(requestParameters.body, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     *
		     * @summary Generate JSON Schema dynamically.
		     * @param {CustomFormsBetaApiCreateFormDefinitionDynamicSchemaRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof CustomFormsBetaApi
		     */
		    CustomFormsBetaApi.prototype.createFormDefinitionDynamicSchema = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.CustomFormsBetaApiFp)(this.configuration).createFormDefinitionDynamicSchema(requestParameters.body, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Parameter `{formDefinitionID}` should match a form definition ID.
		     * @summary Upload new form definition file.
		     * @param {CustomFormsBetaApiCreateFormDefinitionFileRequestRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof CustomFormsBetaApi
		     */
		    CustomFormsBetaApi.prototype.createFormDefinitionFileRequest = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.CustomFormsBetaApiFp)(this.configuration).createFormDefinitionFileRequest(requestParameters.formDefinitionID, requestParameters.file, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     *
		     * @summary Creates a form instance.
		     * @param {CustomFormsBetaApiCreateFormInstanceRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof CustomFormsBetaApi
		     */
		    CustomFormsBetaApi.prototype.createFormInstance = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.CustomFormsBetaApiFp)(this.configuration).createFormInstance(requestParameters.body, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Parameter `{formDefinitionID}` should match a form definition ID.
		     * @summary Deletes a form definition.
		     * @param {CustomFormsBetaApiDeleteFormDefinitionRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof CustomFormsBetaApi
		     */
		    CustomFormsBetaApi.prototype.deleteFormDefinition = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.CustomFormsBetaApiFp)(this.configuration).deleteFormDefinition(requestParameters.formDefinitionID, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * No parameters required.
		     * @summary List form definitions by tenant.
		     * @param {CustomFormsBetaApiExportFormDefinitionsByTenantRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof CustomFormsBetaApi
		     */
		    CustomFormsBetaApi.prototype.exportFormDefinitionsByTenant = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.CustomFormsBetaApiFp)(this.configuration).exportFormDefinitionsByTenant(requestParameters.offset, requestParameters.limit, requestParameters.filters, requestParameters.sorters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     *
		     * @summary Download definition file by fileId.
		     * @param {CustomFormsBetaApiGetFileFromS3Request} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof CustomFormsBetaApi
		     */
		    CustomFormsBetaApi.prototype.getFileFromS3 = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.CustomFormsBetaApiFp)(this.configuration).getFileFromS3(requestParameters.formDefinitionID, requestParameters.fileID, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Parameter `{formDefinitionID}` should match a form definition ID.
		     * @summary Return a form definition.
		     * @param {CustomFormsBetaApiGetFormDefinitionByKeyRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof CustomFormsBetaApi
		     */
		    CustomFormsBetaApi.prototype.getFormDefinitionByKey = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.CustomFormsBetaApiFp)(this.configuration).getFormDefinitionByKey(requestParameters.formDefinitionID, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Parameter `{formInstanceID}` should match a form instance ID.
		     * @summary Returns a form instance.
		     * @param {CustomFormsBetaApiGetFormInstanceByKeyRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof CustomFormsBetaApi
		     */
		    CustomFormsBetaApi.prototype.getFormInstanceByKey = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.CustomFormsBetaApiFp)(this.configuration).getFormInstanceByKey(requestParameters.formInstanceID, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     *
		     * @summary Download instance file by fileId.
		     * @param {CustomFormsBetaApiGetFormInstanceFileRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof CustomFormsBetaApi
		     */
		    CustomFormsBetaApi.prototype.getFormInstanceFile = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.CustomFormsBetaApiFp)(this.configuration).getFormInstanceFile(requestParameters.formInstanceID, requestParameters.fileID, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     *
		     * @summary Import form definitions from export.
		     * @param {CustomFormsBetaApiImportFormDefinitionsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof CustomFormsBetaApi
		     */
		    CustomFormsBetaApi.prototype.importFormDefinitions = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.CustomFormsBetaApiFp)(this.configuration).importFormDefinitions(requestParameters.body, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Parameter `{formDefinitionID}` should match a form definition ID.
		     * @summary Patch a form definition.
		     * @param {CustomFormsBetaApiPatchFormDefinitionRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof CustomFormsBetaApi
		     */
		    CustomFormsBetaApi.prototype.patchFormDefinition = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.CustomFormsBetaApiFp)(this.configuration).patchFormDefinition(requestParameters.formDefinitionID, requestParameters.body, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Parameter `{formInstanceID}` should match a form instance ID.
		     * @summary Patch a form instance.
		     * @param {CustomFormsBetaApiPatchFormInstanceRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof CustomFormsBetaApi
		     */
		    CustomFormsBetaApi.prototype.patchFormInstance = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.CustomFormsBetaApiFp)(this.configuration).patchFormInstance(requestParameters.formInstanceID, requestParameters.body, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * No parameters required.
		     * @summary Export form definitions by tenant.
		     * @param {CustomFormsBetaApiSearchFormDefinitionsByTenantRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof CustomFormsBetaApi
		     */
		    CustomFormsBetaApi.prototype.searchFormDefinitionsByTenant = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.CustomFormsBetaApiFp)(this.configuration).searchFormDefinitionsByTenant(requestParameters.offset, requestParameters.limit, requestParameters.filters, requestParameters.sorters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Parameter `{formInstanceID}` should match a form instance ID. Parameter `{formElementID}` should match a form element ID at the data source configuration.
		     * @summary Retrieves dynamic data by element.
		     * @param {CustomFormsBetaApiSearchFormElementDataByElementIDRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof CustomFormsBetaApi
		     */
		    CustomFormsBetaApi.prototype.searchFormElementDataByElementID = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.CustomFormsBetaApiFp)(this.configuration).searchFormElementDataByElementID(requestParameters.formInstanceID, requestParameters.formElementID, requestParameters.limit, requestParameters.filters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * No parameters required.
		     * @summary List form instances by tenant.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof CustomFormsBetaApi
		     */
		    CustomFormsBetaApi.prototype.searchFormInstancesByTenant = function (axiosOptions) {
		        var _this = this;
		        return (0, exports.CustomFormsBetaApiFp)(this.configuration).searchFormInstancesByTenant(axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * No parameters required.
		     * @summary List predefined select options.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof CustomFormsBetaApi
		     */
		    CustomFormsBetaApi.prototype.searchPreDefinedSelectOptions = function (axiosOptions) {
		        var _this = this;
		        return (0, exports.CustomFormsBetaApiFp)(this.configuration).searchPreDefinedSelectOptions(axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     *
		     * @summary Preview form definition data source.
		     * @param {CustomFormsBetaApiShowPreviewDataSourceRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof CustomFormsBetaApi
		     */
		    CustomFormsBetaApi.prototype.showPreviewDataSource = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.CustomFormsBetaApiFp)(this.configuration).showPreviewDataSource(requestParameters.formDefinitionID, requestParameters.limit, requestParameters.filters, requestParameters.query, requestParameters.formElementPreviewRequestBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return CustomFormsBetaApi;
		}(base_1.BaseAPI));
		exports.CustomFormsBetaApi = CustomFormsBetaApi;
		/**
		 * CustomPasswordInstructionsBetaApi - axios parameter creator
		 * @export
		 */
		var CustomPasswordInstructionsBetaApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * This API creates the custom password instructions for the specified page ID. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Create Custom Password Instructions
		         * @param {CustomPasswordInstructionBeta} customPasswordInstructionBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createCustomPasswordInstructions: function (customPasswordInstructionBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'customPasswordInstructionBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('createCustomPasswordInstructions', 'customPasswordInstructionBeta', customPasswordInstructionBeta);
		                            localVarPath = "/custom-password-instructions";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(customPasswordInstructionBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API delete the custom password instructions for the specified page ID. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Delete Custom Password Instructions by page ID
		         * @param {'change-password:enter-password' | 'change-password:finish' | 'flow-selection:select' | 'forget-username:user-email' | 'mfa:enter-code' | 'mfa:enter-kba' | 'mfa:select' | 'reset-password:enter-password' | 'reset-password:enter-username' | 'reset-password:finish' | 'unlock-account:enter-username' | 'unlock-account:finish'} pageId The page ID of custom password instructions to delete.
		         * @param {string} [locale] The locale for the custom instructions, a BCP47 language tag. The default value is \\\&quot;default\\\&quot;.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteCustomPasswordInstructions: function (pageId, locale, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'pageId' is not null or undefined
		                            (0, common_1.assertParamExists)('deleteCustomPasswordInstructions', 'pageId', pageId);
		                            localVarPath = "/custom-password-instructions/{pageId}"
		                                .replace("{".concat("pageId", "}"), encodeURIComponent(String(pageId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'DELETE' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (locale !== undefined) {
		                                localVarQueryParameter['locale'] = locale;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns the custom password instructions for the specified page ID. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Get Custom Password Instructions by Page ID
		         * @param {'change-password:enter-password' | 'change-password:finish' | 'flow-selection:select' | 'forget-username:user-email' | 'mfa:enter-code' | 'mfa:enter-kba' | 'mfa:select' | 'reset-password:enter-password' | 'reset-password:enter-username' | 'reset-password:finish' | 'unlock-account:enter-username' | 'unlock-account:finish'} pageId The page ID of custom password instructions to query.
		         * @param {string} [locale] The locale for the custom instructions, a BCP47 language tag. The default value is \\\&quot;default\\\&quot;.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getCustomPasswordInstructions: function (pageId, locale, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'pageId' is not null or undefined
		                            (0, common_1.assertParamExists)('getCustomPasswordInstructions', 'pageId', pageId);
		                            localVarPath = "/custom-password-instructions/{pageId}"
		                                .replace("{".concat("pageId", "}"), encodeURIComponent(String(pageId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (locale !== undefined) {
		                                localVarQueryParameter['locale'] = locale;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.CustomPasswordInstructionsBetaApiAxiosParamCreator = CustomPasswordInstructionsBetaApiAxiosParamCreator;
		/**
		 * CustomPasswordInstructionsBetaApi - functional programming interface
		 * @export
		 */
		var CustomPasswordInstructionsBetaApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.CustomPasswordInstructionsBetaApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * This API creates the custom password instructions for the specified page ID. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Create Custom Password Instructions
		         * @param {CustomPasswordInstructionBeta} customPasswordInstructionBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createCustomPasswordInstructions: function (customPasswordInstructionBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.createCustomPasswordInstructions(customPasswordInstructionBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API delete the custom password instructions for the specified page ID. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Delete Custom Password Instructions by page ID
		         * @param {'change-password:enter-password' | 'change-password:finish' | 'flow-selection:select' | 'forget-username:user-email' | 'mfa:enter-code' | 'mfa:enter-kba' | 'mfa:select' | 'reset-password:enter-password' | 'reset-password:enter-username' | 'reset-password:finish' | 'unlock-account:enter-username' | 'unlock-account:finish'} pageId The page ID of custom password instructions to delete.
		         * @param {string} [locale] The locale for the custom instructions, a BCP47 language tag. The default value is \\\&quot;default\\\&quot;.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteCustomPasswordInstructions: function (pageId, locale, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.deleteCustomPasswordInstructions(pageId, locale, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns the custom password instructions for the specified page ID. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Get Custom Password Instructions by Page ID
		         * @param {'change-password:enter-password' | 'change-password:finish' | 'flow-selection:select' | 'forget-username:user-email' | 'mfa:enter-code' | 'mfa:enter-kba' | 'mfa:select' | 'reset-password:enter-password' | 'reset-password:enter-username' | 'reset-password:finish' | 'unlock-account:enter-username' | 'unlock-account:finish'} pageId The page ID of custom password instructions to query.
		         * @param {string} [locale] The locale for the custom instructions, a BCP47 language tag. The default value is \\\&quot;default\\\&quot;.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getCustomPasswordInstructions: function (pageId, locale, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getCustomPasswordInstructions(pageId, locale, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.CustomPasswordInstructionsBetaApiFp = CustomPasswordInstructionsBetaApiFp;
		/**
		 * CustomPasswordInstructionsBetaApi - factory interface
		 * @export
		 */
		var CustomPasswordInstructionsBetaApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.CustomPasswordInstructionsBetaApiFp)(configuration);
		    return {
		        /**
		         * This API creates the custom password instructions for the specified page ID. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Create Custom Password Instructions
		         * @param {CustomPasswordInstructionBeta} customPasswordInstructionBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createCustomPasswordInstructions: function (customPasswordInstructionBeta, axiosOptions) {
		            return localVarFp.createCustomPasswordInstructions(customPasswordInstructionBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API delete the custom password instructions for the specified page ID. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Delete Custom Password Instructions by page ID
		         * @param {'change-password:enter-password' | 'change-password:finish' | 'flow-selection:select' | 'forget-username:user-email' | 'mfa:enter-code' | 'mfa:enter-kba' | 'mfa:select' | 'reset-password:enter-password' | 'reset-password:enter-username' | 'reset-password:finish' | 'unlock-account:enter-username' | 'unlock-account:finish'} pageId The page ID of custom password instructions to delete.
		         * @param {string} [locale] The locale for the custom instructions, a BCP47 language tag. The default value is \\\&quot;default\\\&quot;.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteCustomPasswordInstructions: function (pageId, locale, axiosOptions) {
		            return localVarFp.deleteCustomPasswordInstructions(pageId, locale, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API returns the custom password instructions for the specified page ID. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Get Custom Password Instructions by Page ID
		         * @param {'change-password:enter-password' | 'change-password:finish' | 'flow-selection:select' | 'forget-username:user-email' | 'mfa:enter-code' | 'mfa:enter-kba' | 'mfa:select' | 'reset-password:enter-password' | 'reset-password:enter-username' | 'reset-password:finish' | 'unlock-account:enter-username' | 'unlock-account:finish'} pageId The page ID of custom password instructions to query.
		         * @param {string} [locale] The locale for the custom instructions, a BCP47 language tag. The default value is \\\&quot;default\\\&quot;.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getCustomPasswordInstructions: function (pageId, locale, axiosOptions) {
		            return localVarFp.getCustomPasswordInstructions(pageId, locale, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.CustomPasswordInstructionsBetaApiFactory = CustomPasswordInstructionsBetaApiFactory;
		/**
		 * CustomPasswordInstructionsBetaApi - object-oriented interface
		 * @export
		 * @class CustomPasswordInstructionsBetaApi
		 * @extends {BaseAPI}
		 */
		var CustomPasswordInstructionsBetaApi = /** @class */ (function (_super) {
		    __extends(CustomPasswordInstructionsBetaApi, _super);
		    function CustomPasswordInstructionsBetaApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * This API creates the custom password instructions for the specified page ID. A token with ORG_ADMIN authority is required to call this API.
		     * @summary Create Custom Password Instructions
		     * @param {CustomPasswordInstructionsBetaApiCreateCustomPasswordInstructionsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof CustomPasswordInstructionsBetaApi
		     */
		    CustomPasswordInstructionsBetaApi.prototype.createCustomPasswordInstructions = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.CustomPasswordInstructionsBetaApiFp)(this.configuration).createCustomPasswordInstructions(requestParameters.customPasswordInstructionBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API delete the custom password instructions for the specified page ID. A token with ORG_ADMIN authority is required to call this API.
		     * @summary Delete Custom Password Instructions by page ID
		     * @param {CustomPasswordInstructionsBetaApiDeleteCustomPasswordInstructionsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof CustomPasswordInstructionsBetaApi
		     */
		    CustomPasswordInstructionsBetaApi.prototype.deleteCustomPasswordInstructions = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.CustomPasswordInstructionsBetaApiFp)(this.configuration).deleteCustomPasswordInstructions(requestParameters.pageId, requestParameters.locale, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API returns the custom password instructions for the specified page ID. A token with ORG_ADMIN authority is required to call this API.
		     * @summary Get Custom Password Instructions by Page ID
		     * @param {CustomPasswordInstructionsBetaApiGetCustomPasswordInstructionsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof CustomPasswordInstructionsBetaApi
		     */
		    CustomPasswordInstructionsBetaApi.prototype.getCustomPasswordInstructions = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.CustomPasswordInstructionsBetaApiFp)(this.configuration).getCustomPasswordInstructions(requestParameters.pageId, requestParameters.locale, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return CustomPasswordInstructionsBetaApi;
		}(base_1.BaseAPI));
		exports.CustomPasswordInstructionsBetaApi = CustomPasswordInstructionsBetaApi;
		/**
		 * EntitlementsBetaApi - axios parameter creator
		 * @export
		 */
		var EntitlementsBetaApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * This API returns an entitlement by its ID.
		         * @summary Get an entitlement
		         * @param {string} id The entitlement ID
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getEntitlement: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getEntitlement', 'id', id);
		                            localVarPath = "/entitlements/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns the entitlement request config for a specified entitlement.
		         * @summary Get Entitlement Request Config
		         * @param {string} id Entitlement Id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getEntitlementRequestConfig: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getEntitlementRequestConfig', 'id', id);
		                            localVarPath = "/entitlements/{id}/entitlement-request-config"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns a list of all child entitlements of a given entitlement.
		         * @summary List of entitlements children
		         * @param {string} id Entitlement Id
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **id, name, created, modified, type, attribute, value, source.id**
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **name**: *eq, in, sw*  **type**: *eq, in*  **attribute**: *eq, in*  **value**: *eq, in, sw*  **source.id**: *eq, in*  **requestable**: *eq*  **created**: *gt, lt, ge, le*  **modified**: *gt, lt, ge, le*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listEntitlementChildren: function (id, limit, offset, count, sorters, filters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('listEntitlementChildren', 'id', id);
		                            localVarPath = "/entitlements/{id}/children"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns a list of all parent entitlements of a given entitlement.
		         * @summary List of entitlements parents
		         * @param {string} id Entitlement Id
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **id, name, created, modified, type, attribute, value, source.id**
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **name**: *eq, in, sw*  **type**: *eq, in*  **attribute**: *eq, in*  **value**: *eq, in, sw*  **source.id**: *eq, in*  **requestable**: *eq*  **created**: *gt, lt, ge, le*  **modified**: *gt, lt, ge, le*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listEntitlementParents: function (id, limit, offset, count, sorters, filters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('listEntitlementParents', 'id', id);
		                            localVarPath = "/entitlements/{id}/parents"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns a list of entitlements.  This API can be used in one of the two following ways: either getting entitlements for a specific **account-id**, or getting via use of **filters** (those two options are exclusive).  Any authenticated token can call this API.
		         * @summary Gets a list of entitlements.
		         * @param {string} [accountId] The account ID. If specified, returns only entitlements associated with the given Account. Cannot be specified with the **filters**, **segmented-for-identity**, **for-segment-ids**, or **include-unsegmented** param(s).
		         * @param {string} [segmentedForIdentity] If present and not empty, additionally filters Entitlements to those which are assigned to the Segment(s) which are visible to the Identity with the specified ID. By convention, the value **me** can stand in for the current user\&#39;s Identity ID. Cannot be specified with the **account-id** or **for-segment-ids** param(s). It is also illegal to specify a value that refers to a different user\&#39;s Identity.
		         * @param {string} [forSegmentIds] If present and not empty, additionally filters Access Profiles to those which are assigned to the Segment(s) with the specified IDs. Cannot be specified with the **account-id** or **segmented-for-identity** param(s).
		         * @param {boolean} [includeUnsegmented] Whether or not the response list should contain unsegmented Entitlements. If **for-segment-ids** and **segmented-for-identity** are both absent or empty, specifying **include-unsegmented&#x3D;false** results in an error.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **id, name, created, modified, type, attribute, value, source.id, requestable**
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **name**: *eq, in, sw*  **type**: *eq, in*  **attribute**: *eq, in*  **value**: *eq, in, sw*  **source.id**: *eq, in*  **requestable**: *eq*  **created**: *gt, lt, ge, le*  **modified**: *gt, lt, ge, le*  **owner.id**: *eq, in*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listEntitlements: function (accountId, segmentedForIdentity, forSegmentIds, includeUnsegmented, offset, limit, count, sorters, filters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/entitlements";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (accountId !== undefined) {
		                                localVarQueryParameter['account-id'] = accountId;
		                            }
		                            if (segmentedForIdentity !== undefined) {
		                                localVarQueryParameter['segmented-for-identity'] = segmentedForIdentity;
		                            }
		                            if (forSegmentIds !== undefined) {
		                                localVarQueryParameter['for-segment-ids'] = forSegmentIds;
		                            }
		                            if (includeUnsegmented !== undefined) {
		                                localVarQueryParameter['include-unsegmented'] = includeUnsegmented;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API updates an existing entitlement using [JSON Patch](https://tools.ietf.org/html/rfc6902) syntax.  The following fields are patchable: **requestable**, **privileged**, **segments**, **owner**, **name**, **description**, and **manuallyUpdatedFields**  When you\'re patching owner, only owner type and owner id must be provided. Owner name is optional, and it won\'t be modified. If the owner name is provided, it should correspond to the real name. The only owner type currently supported is IDENTITY.  A token with ORG_ADMIN or SOURCE_ADMIN authority is required to call this API.
		         * @summary Patch an entitlement
		         * @param {string} id ID of the entitlement to patch
		         * @param {Array<JsonPatchOperationBeta>} [jsonPatchOperationBeta]
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchEntitlement: function (id, jsonPatchOperationBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('patchEntitlement', 'id', id);
		                            localVarPath = "/entitlements/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PATCH' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json-patch+json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(jsonPatchOperationBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API replaces the entitlement request config for a specified entitlement.
		         * @summary Replace Entitlement Request Config
		         * @param {string} id Entitlement ID
		         * @param {EntitlementRequestConfigBeta} entitlementRequestConfigBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putEntitlementRequestConfig: function (id, entitlementRequestConfigBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('putEntitlementRequestConfig', 'id', id);
		                            // verify required parameter 'entitlementRequestConfigBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('putEntitlementRequestConfig', 'entitlementRequestConfigBeta', entitlementRequestConfigBeta);
		                            localVarPath = "/entitlements/{id}/entitlement-request-config"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PUT' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(entitlementRequestConfigBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API applies an update to every entitlement of the list.  The number of entitlements to update is limited to 50 items maximum.  The JsonPatch update follows the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard. allowed operations : **{ \"op\": \"replace\", \"path\": \"/privileged\", \"value\": boolean }**  **{ \"op\": \"replace\", \"path\": \"/requestable\",\"value\": boolean }**   A token with ORG_ADMIN or API authority is required to call this API.
		         * @summary Bulk update an entitlement list
		         * @param {EntitlementBulkUpdateRequestBeta} entitlementBulkUpdateRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateEntitlementsInBulk: function (entitlementBulkUpdateRequestBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'entitlementBulkUpdateRequestBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('updateEntitlementsInBulk', 'entitlementBulkUpdateRequestBeta', entitlementBulkUpdateRequestBeta);
		                            localVarPath = "/entitlements/bulk-update";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(entitlementBulkUpdateRequestBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.EntitlementsBetaApiAxiosParamCreator = EntitlementsBetaApiAxiosParamCreator;
		/**
		 * EntitlementsBetaApi - functional programming interface
		 * @export
		 */
		var EntitlementsBetaApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.EntitlementsBetaApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * This API returns an entitlement by its ID.
		         * @summary Get an entitlement
		         * @param {string} id The entitlement ID
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getEntitlement: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getEntitlement(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns the entitlement request config for a specified entitlement.
		         * @summary Get Entitlement Request Config
		         * @param {string} id Entitlement Id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getEntitlementRequestConfig: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getEntitlementRequestConfig(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns a list of all child entitlements of a given entitlement.
		         * @summary List of entitlements children
		         * @param {string} id Entitlement Id
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **id, name, created, modified, type, attribute, value, source.id**
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **name**: *eq, in, sw*  **type**: *eq, in*  **attribute**: *eq, in*  **value**: *eq, in, sw*  **source.id**: *eq, in*  **requestable**: *eq*  **created**: *gt, lt, ge, le*  **modified**: *gt, lt, ge, le*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listEntitlementChildren: function (id, limit, offset, count, sorters, filters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listEntitlementChildren(id, limit, offset, count, sorters, filters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns a list of all parent entitlements of a given entitlement.
		         * @summary List of entitlements parents
		         * @param {string} id Entitlement Id
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **id, name, created, modified, type, attribute, value, source.id**
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **name**: *eq, in, sw*  **type**: *eq, in*  **attribute**: *eq, in*  **value**: *eq, in, sw*  **source.id**: *eq, in*  **requestable**: *eq*  **created**: *gt, lt, ge, le*  **modified**: *gt, lt, ge, le*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listEntitlementParents: function (id, limit, offset, count, sorters, filters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listEntitlementParents(id, limit, offset, count, sorters, filters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns a list of entitlements.  This API can be used in one of the two following ways: either getting entitlements for a specific **account-id**, or getting via use of **filters** (those two options are exclusive).  Any authenticated token can call this API.
		         * @summary Gets a list of entitlements.
		         * @param {string} [accountId] The account ID. If specified, returns only entitlements associated with the given Account. Cannot be specified with the **filters**, **segmented-for-identity**, **for-segment-ids**, or **include-unsegmented** param(s).
		         * @param {string} [segmentedForIdentity] If present and not empty, additionally filters Entitlements to those which are assigned to the Segment(s) which are visible to the Identity with the specified ID. By convention, the value **me** can stand in for the current user\&#39;s Identity ID. Cannot be specified with the **account-id** or **for-segment-ids** param(s). It is also illegal to specify a value that refers to a different user\&#39;s Identity.
		         * @param {string} [forSegmentIds] If present and not empty, additionally filters Access Profiles to those which are assigned to the Segment(s) with the specified IDs. Cannot be specified with the **account-id** or **segmented-for-identity** param(s).
		         * @param {boolean} [includeUnsegmented] Whether or not the response list should contain unsegmented Entitlements. If **for-segment-ids** and **segmented-for-identity** are both absent or empty, specifying **include-unsegmented&#x3D;false** results in an error.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **id, name, created, modified, type, attribute, value, source.id, requestable**
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **name**: *eq, in, sw*  **type**: *eq, in*  **attribute**: *eq, in*  **value**: *eq, in, sw*  **source.id**: *eq, in*  **requestable**: *eq*  **created**: *gt, lt, ge, le*  **modified**: *gt, lt, ge, le*  **owner.id**: *eq, in*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listEntitlements: function (accountId, segmentedForIdentity, forSegmentIds, includeUnsegmented, offset, limit, count, sorters, filters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listEntitlements(accountId, segmentedForIdentity, forSegmentIds, includeUnsegmented, offset, limit, count, sorters, filters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API updates an existing entitlement using [JSON Patch](https://tools.ietf.org/html/rfc6902) syntax.  The following fields are patchable: **requestable**, **privileged**, **segments**, **owner**, **name**, **description**, and **manuallyUpdatedFields**  When you\'re patching owner, only owner type and owner id must be provided. Owner name is optional, and it won\'t be modified. If the owner name is provided, it should correspond to the real name. The only owner type currently supported is IDENTITY.  A token with ORG_ADMIN or SOURCE_ADMIN authority is required to call this API.
		         * @summary Patch an entitlement
		         * @param {string} id ID of the entitlement to patch
		         * @param {Array<JsonPatchOperationBeta>} [jsonPatchOperationBeta]
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchEntitlement: function (id, jsonPatchOperationBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.patchEntitlement(id, jsonPatchOperationBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API replaces the entitlement request config for a specified entitlement.
		         * @summary Replace Entitlement Request Config
		         * @param {string} id Entitlement ID
		         * @param {EntitlementRequestConfigBeta} entitlementRequestConfigBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putEntitlementRequestConfig: function (id, entitlementRequestConfigBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.putEntitlementRequestConfig(id, entitlementRequestConfigBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API applies an update to every entitlement of the list.  The number of entitlements to update is limited to 50 items maximum.  The JsonPatch update follows the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard. allowed operations : **{ \"op\": \"replace\", \"path\": \"/privileged\", \"value\": boolean }**  **{ \"op\": \"replace\", \"path\": \"/requestable\",\"value\": boolean }**   A token with ORG_ADMIN or API authority is required to call this API.
		         * @summary Bulk update an entitlement list
		         * @param {EntitlementBulkUpdateRequestBeta} entitlementBulkUpdateRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateEntitlementsInBulk: function (entitlementBulkUpdateRequestBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.updateEntitlementsInBulk(entitlementBulkUpdateRequestBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.EntitlementsBetaApiFp = EntitlementsBetaApiFp;
		/**
		 * EntitlementsBetaApi - factory interface
		 * @export
		 */
		var EntitlementsBetaApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.EntitlementsBetaApiFp)(configuration);
		    return {
		        /**
		         * This API returns an entitlement by its ID.
		         * @summary Get an entitlement
		         * @param {string} id The entitlement ID
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getEntitlement: function (id, axiosOptions) {
		            return localVarFp.getEntitlement(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API returns the entitlement request config for a specified entitlement.
		         * @summary Get Entitlement Request Config
		         * @param {string} id Entitlement Id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getEntitlementRequestConfig: function (id, axiosOptions) {
		            return localVarFp.getEntitlementRequestConfig(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API returns a list of all child entitlements of a given entitlement.
		         * @summary List of entitlements children
		         * @param {string} id Entitlement Id
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **id, name, created, modified, type, attribute, value, source.id**
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **name**: *eq, in, sw*  **type**: *eq, in*  **attribute**: *eq, in*  **value**: *eq, in, sw*  **source.id**: *eq, in*  **requestable**: *eq*  **created**: *gt, lt, ge, le*  **modified**: *gt, lt, ge, le*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listEntitlementChildren: function (id, limit, offset, count, sorters, filters, axiosOptions) {
		            return localVarFp.listEntitlementChildren(id, limit, offset, count, sorters, filters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API returns a list of all parent entitlements of a given entitlement.
		         * @summary List of entitlements parents
		         * @param {string} id Entitlement Id
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **id, name, created, modified, type, attribute, value, source.id**
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **name**: *eq, in, sw*  **type**: *eq, in*  **attribute**: *eq, in*  **value**: *eq, in, sw*  **source.id**: *eq, in*  **requestable**: *eq*  **created**: *gt, lt, ge, le*  **modified**: *gt, lt, ge, le*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listEntitlementParents: function (id, limit, offset, count, sorters, filters, axiosOptions) {
		            return localVarFp.listEntitlementParents(id, limit, offset, count, sorters, filters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API returns a list of entitlements.  This API can be used in one of the two following ways: either getting entitlements for a specific **account-id**, or getting via use of **filters** (those two options are exclusive).  Any authenticated token can call this API.
		         * @summary Gets a list of entitlements.
		         * @param {string} [accountId] The account ID. If specified, returns only entitlements associated with the given Account. Cannot be specified with the **filters**, **segmented-for-identity**, **for-segment-ids**, or **include-unsegmented** param(s).
		         * @param {string} [segmentedForIdentity] If present and not empty, additionally filters Entitlements to those which are assigned to the Segment(s) which are visible to the Identity with the specified ID. By convention, the value **me** can stand in for the current user\&#39;s Identity ID. Cannot be specified with the **account-id** or **for-segment-ids** param(s). It is also illegal to specify a value that refers to a different user\&#39;s Identity.
		         * @param {string} [forSegmentIds] If present and not empty, additionally filters Access Profiles to those which are assigned to the Segment(s) with the specified IDs. Cannot be specified with the **account-id** or **segmented-for-identity** param(s).
		         * @param {boolean} [includeUnsegmented] Whether or not the response list should contain unsegmented Entitlements. If **for-segment-ids** and **segmented-for-identity** are both absent or empty, specifying **include-unsegmented&#x3D;false** results in an error.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **id, name, created, modified, type, attribute, value, source.id, requestable**
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **name**: *eq, in, sw*  **type**: *eq, in*  **attribute**: *eq, in*  **value**: *eq, in, sw*  **source.id**: *eq, in*  **requestable**: *eq*  **created**: *gt, lt, ge, le*  **modified**: *gt, lt, ge, le*  **owner.id**: *eq, in*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listEntitlements: function (accountId, segmentedForIdentity, forSegmentIds, includeUnsegmented, offset, limit, count, sorters, filters, axiosOptions) {
		            return localVarFp.listEntitlements(accountId, segmentedForIdentity, forSegmentIds, includeUnsegmented, offset, limit, count, sorters, filters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API updates an existing entitlement using [JSON Patch](https://tools.ietf.org/html/rfc6902) syntax.  The following fields are patchable: **requestable**, **privileged**, **segments**, **owner**, **name**, **description**, and **manuallyUpdatedFields**  When you\'re patching owner, only owner type and owner id must be provided. Owner name is optional, and it won\'t be modified. If the owner name is provided, it should correspond to the real name. The only owner type currently supported is IDENTITY.  A token with ORG_ADMIN or SOURCE_ADMIN authority is required to call this API.
		         * @summary Patch an entitlement
		         * @param {string} id ID of the entitlement to patch
		         * @param {Array<JsonPatchOperationBeta>} [jsonPatchOperationBeta]
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchEntitlement: function (id, jsonPatchOperationBeta, axiosOptions) {
		            return localVarFp.patchEntitlement(id, jsonPatchOperationBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API replaces the entitlement request config for a specified entitlement.
		         * @summary Replace Entitlement Request Config
		         * @param {string} id Entitlement ID
		         * @param {EntitlementRequestConfigBeta} entitlementRequestConfigBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putEntitlementRequestConfig: function (id, entitlementRequestConfigBeta, axiosOptions) {
		            return localVarFp.putEntitlementRequestConfig(id, entitlementRequestConfigBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API applies an update to every entitlement of the list.  The number of entitlements to update is limited to 50 items maximum.  The JsonPatch update follows the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard. allowed operations : **{ \"op\": \"replace\", \"path\": \"/privileged\", \"value\": boolean }**  **{ \"op\": \"replace\", \"path\": \"/requestable\",\"value\": boolean }**   A token with ORG_ADMIN or API authority is required to call this API.
		         * @summary Bulk update an entitlement list
		         * @param {EntitlementBulkUpdateRequestBeta} entitlementBulkUpdateRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateEntitlementsInBulk: function (entitlementBulkUpdateRequestBeta, axiosOptions) {
		            return localVarFp.updateEntitlementsInBulk(entitlementBulkUpdateRequestBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.EntitlementsBetaApiFactory = EntitlementsBetaApiFactory;
		/**
		 * EntitlementsBetaApi - object-oriented interface
		 * @export
		 * @class EntitlementsBetaApi
		 * @extends {BaseAPI}
		 */
		var EntitlementsBetaApi = /** @class */ (function (_super) {
		    __extends(EntitlementsBetaApi, _super);
		    function EntitlementsBetaApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * This API returns an entitlement by its ID.
		     * @summary Get an entitlement
		     * @param {EntitlementsBetaApiGetEntitlementRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof EntitlementsBetaApi
		     */
		    EntitlementsBetaApi.prototype.getEntitlement = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.EntitlementsBetaApiFp)(this.configuration).getEntitlement(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API returns the entitlement request config for a specified entitlement.
		     * @summary Get Entitlement Request Config
		     * @param {EntitlementsBetaApiGetEntitlementRequestConfigRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof EntitlementsBetaApi
		     */
		    EntitlementsBetaApi.prototype.getEntitlementRequestConfig = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.EntitlementsBetaApiFp)(this.configuration).getEntitlementRequestConfig(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API returns a list of all child entitlements of a given entitlement.
		     * @summary List of entitlements children
		     * @param {EntitlementsBetaApiListEntitlementChildrenRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof EntitlementsBetaApi
		     */
		    EntitlementsBetaApi.prototype.listEntitlementChildren = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.EntitlementsBetaApiFp)(this.configuration).listEntitlementChildren(requestParameters.id, requestParameters.limit, requestParameters.offset, requestParameters.count, requestParameters.sorters, requestParameters.filters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API returns a list of all parent entitlements of a given entitlement.
		     * @summary List of entitlements parents
		     * @param {EntitlementsBetaApiListEntitlementParentsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof EntitlementsBetaApi
		     */
		    EntitlementsBetaApi.prototype.listEntitlementParents = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.EntitlementsBetaApiFp)(this.configuration).listEntitlementParents(requestParameters.id, requestParameters.limit, requestParameters.offset, requestParameters.count, requestParameters.sorters, requestParameters.filters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API returns a list of entitlements.  This API can be used in one of the two following ways: either getting entitlements for a specific **account-id**, or getting via use of **filters** (those two options are exclusive).  Any authenticated token can call this API.
		     * @summary Gets a list of entitlements.
		     * @param {EntitlementsBetaApiListEntitlementsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof EntitlementsBetaApi
		     */
		    EntitlementsBetaApi.prototype.listEntitlements = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.EntitlementsBetaApiFp)(this.configuration).listEntitlements(requestParameters.accountId, requestParameters.segmentedForIdentity, requestParameters.forSegmentIds, requestParameters.includeUnsegmented, requestParameters.offset, requestParameters.limit, requestParameters.count, requestParameters.sorters, requestParameters.filters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API updates an existing entitlement using [JSON Patch](https://tools.ietf.org/html/rfc6902) syntax.  The following fields are patchable: **requestable**, **privileged**, **segments**, **owner**, **name**, **description**, and **manuallyUpdatedFields**  When you\'re patching owner, only owner type and owner id must be provided. Owner name is optional, and it won\'t be modified. If the owner name is provided, it should correspond to the real name. The only owner type currently supported is IDENTITY.  A token with ORG_ADMIN or SOURCE_ADMIN authority is required to call this API.
		     * @summary Patch an entitlement
		     * @param {EntitlementsBetaApiPatchEntitlementRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof EntitlementsBetaApi
		     */
		    EntitlementsBetaApi.prototype.patchEntitlement = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.EntitlementsBetaApiFp)(this.configuration).patchEntitlement(requestParameters.id, requestParameters.jsonPatchOperationBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API replaces the entitlement request config for a specified entitlement.
		     * @summary Replace Entitlement Request Config
		     * @param {EntitlementsBetaApiPutEntitlementRequestConfigRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof EntitlementsBetaApi
		     */
		    EntitlementsBetaApi.prototype.putEntitlementRequestConfig = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.EntitlementsBetaApiFp)(this.configuration).putEntitlementRequestConfig(requestParameters.id, requestParameters.entitlementRequestConfigBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API applies an update to every entitlement of the list.  The number of entitlements to update is limited to 50 items maximum.  The JsonPatch update follows the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard. allowed operations : **{ \"op\": \"replace\", \"path\": \"/privileged\", \"value\": boolean }**  **{ \"op\": \"replace\", \"path\": \"/requestable\",\"value\": boolean }**   A token with ORG_ADMIN or API authority is required to call this API.
		     * @summary Bulk update an entitlement list
		     * @param {EntitlementsBetaApiUpdateEntitlementsInBulkRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof EntitlementsBetaApi
		     */
		    EntitlementsBetaApi.prototype.updateEntitlementsInBulk = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.EntitlementsBetaApiFp)(this.configuration).updateEntitlementsInBulk(requestParameters.entitlementBulkUpdateRequestBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return EntitlementsBetaApi;
		}(base_1.BaseAPI));
		exports.EntitlementsBetaApi = EntitlementsBetaApi;
		/**
		 * GovernanceGroupsBetaApi - axios parameter creator
		 * @export
		 */
		var GovernanceGroupsBetaApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * This API creates a new Governance Group.
		         * @summary Create a new Governance Group.
		         * @param {WorkgroupDtoBeta} workgroupDtoBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createWorkgroup: function (workgroupDtoBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'workgroupDtoBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('createWorkgroup', 'workgroupDtoBeta', workgroupDtoBeta);
		                            localVarPath = "/workgroups";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(workgroupDtoBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API deletes a Governance Group by its ID.
		         * @summary Delete a Governance Group
		         * @param {string} id ID of the Governance Group
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteWorkgroup: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('deleteWorkgroup', 'id', id);
		                            localVarPath = "/workgroups/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'DELETE' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API removes one or more  members from a Governance Group.  A token with API, ORG_ADMIN authority is required to call this API.  >  **Following field of Identity is an optional field in the request.**  >  **name**
		         * @summary Remove members from Governance Group
		         * @param {string} workgroupId ID of the Governance Group.
		         * @param {Array<BulkWorkgroupMembersRequestInnerBeta>} bulkWorkgroupMembersRequestInnerBeta List of identities to be removed from  a Governance Group members list.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteWorkgroupMembers: function (workgroupId, bulkWorkgroupMembersRequestInnerBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'workgroupId' is not null or undefined
		                            (0, common_1.assertParamExists)('deleteWorkgroupMembers', 'workgroupId', workgroupId);
		                            // verify required parameter 'bulkWorkgroupMembersRequestInnerBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('deleteWorkgroupMembers', 'bulkWorkgroupMembersRequestInnerBeta', bulkWorkgroupMembersRequestInnerBeta);
		                            localVarPath = "/workgroups/{workgroupId}/members/bulk-delete"
		                                .replace("{".concat("workgroupId", "}"), encodeURIComponent(String(workgroupId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(bulkWorkgroupMembersRequestInnerBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         *  This API initiates a bulk deletion of one or more Governance Groups.  >  If any of the indicated Governance Groups have one or more connections associated with it,then those Governance Groups will be added in  **inUse** list of the response. Governance Group(s) marked as **inUse** can not be deleted.  >  If any of the indicated Governance Groups is not does not exists in Organization,then those Governance Groups will be added in **notFound** list of the response. Governance Groups marked as **notFound** will not be deleted.  >  If any of the indicated Governance Groups does not have any connections associated with it,then those Governance Groups will be added in **deleted** list of the response. A Governance Group marked as **deleted** will be deleted from current Organization.  >  If the request contains any **inUse** or **notFound** Governance Group IDs then it skips only these Governance Groups for deletion and deletes the rest of Governance Groups which have no connections associated with it.   >  **This API has limit number of Governance Groups can be deleted at one time. If the request contains more then 100 Governance Groups IDs to be deleted then the API will throw an exception.**
		         * @summary Delete Governance Group(s)
		         * @param {WorkgroupBulkDeleteRequestBeta} workgroupBulkDeleteRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteWorkgroupsInBulk: function (workgroupBulkDeleteRequestBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'workgroupBulkDeleteRequestBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('deleteWorkgroupsInBulk', 'workgroupBulkDeleteRequestBeta', workgroupBulkDeleteRequestBeta);
		                            localVarPath = "/workgroups/bulk-delete";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(workgroupBulkDeleteRequestBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns a Governance Groups by its ID.
		         * @summary Get Governance Group by Id
		         * @param {string} id ID of the Governance Group
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getWorkgroup: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getWorkgroup', 'id', id);
		                            localVarPath = "/workgroups/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns list of connections associated with a Governance Group.
		         * @summary List connections for Governance Group
		         * @param {string} workgroupId ID of the Governance Group.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Note that for this API the maximum value for limit is 50. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name, created, modified**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listConnections: function (workgroupId, offset, limit, count, sorters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'workgroupId' is not null or undefined
		                            (0, common_1.assertParamExists)('listConnections', 'workgroupId', workgroupId);
		                            localVarPath = "/workgroups/{workgroupId}/connections"
		                                .replace("{".concat("workgroupId", "}"), encodeURIComponent(String(workgroupId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns list of members associated with a Governance Group.
		         * @summary List Governance Group Members
		         * @param {string} workgroupId ID of the Governance Group.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Note that for this API the maximum value for limit is 50. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name, created, modified**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listWorkgroupMembers: function (workgroupId, offset, limit, count, sorters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'workgroupId' is not null or undefined
		                            (0, common_1.assertParamExists)('listWorkgroupMembers', 'workgroupId', workgroupId);
		                            localVarPath = "/workgroups/{workgroupId}/members"
		                                .replace("{".concat("workgroupId", "}"), encodeURIComponent(String(workgroupId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns list of Governance Groups
		         * @summary List Governance Groups
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Note that for this API the maximum value for limit is 50. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in, sw*  **name**: *eq, sw, in*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name, created, modified, id, description**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listWorkgroups: function (offset, limit, count, filters, sorters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/workgroups";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API updates an existing governance group by ID.  The following fields and objects are patchable:   * name   * description   * owner  A token with API or ORG_ADMIN authority is required to call this API.
		         * @summary Patch a Governance Group
		         * @param {string} id ID of the Governance Group
		         * @param {Array<JsonPatchOperationBeta>} [jsonPatchOperationBeta]
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchWorkgroup: function (id, jsonPatchOperationBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('patchWorkgroup', 'id', id);
		                            localVarPath = "/workgroups/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PATCH' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json-patch+json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(jsonPatchOperationBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API adds one or more members to a Governance Group.  A token with API, ORG_ADMIN authority is required to call this API.  >  **Following field of Identity is an optional field in the request.**  >  **name**
		         * @summary Add members to Governance Group
		         * @param {string} workgroupId ID of the Governance Group.
		         * @param {Array<BulkWorkgroupMembersRequestInnerBeta>} bulkWorkgroupMembersRequestInnerBeta List of identities to be added to a Governance Group members list.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateWorkgroupMembers: function (workgroupId, bulkWorkgroupMembersRequestInnerBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'workgroupId' is not null or undefined
		                            (0, common_1.assertParamExists)('updateWorkgroupMembers', 'workgroupId', workgroupId);
		                            // verify required parameter 'bulkWorkgroupMembersRequestInnerBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('updateWorkgroupMembers', 'bulkWorkgroupMembersRequestInnerBeta', bulkWorkgroupMembersRequestInnerBeta);
		                            localVarPath = "/workgroups/{workgroupId}/members/bulk-add"
		                                .replace("{".concat("workgroupId", "}"), encodeURIComponent(String(workgroupId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(bulkWorkgroupMembersRequestInnerBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.GovernanceGroupsBetaApiAxiosParamCreator = GovernanceGroupsBetaApiAxiosParamCreator;
		/**
		 * GovernanceGroupsBetaApi - functional programming interface
		 * @export
		 */
		var GovernanceGroupsBetaApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.GovernanceGroupsBetaApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * This API creates a new Governance Group.
		         * @summary Create a new Governance Group.
		         * @param {WorkgroupDtoBeta} workgroupDtoBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createWorkgroup: function (workgroupDtoBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.createWorkgroup(workgroupDtoBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API deletes a Governance Group by its ID.
		         * @summary Delete a Governance Group
		         * @param {string} id ID of the Governance Group
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteWorkgroup: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.deleteWorkgroup(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API removes one or more  members from a Governance Group.  A token with API, ORG_ADMIN authority is required to call this API.  >  **Following field of Identity is an optional field in the request.**  >  **name**
		         * @summary Remove members from Governance Group
		         * @param {string} workgroupId ID of the Governance Group.
		         * @param {Array<BulkWorkgroupMembersRequestInnerBeta>} bulkWorkgroupMembersRequestInnerBeta List of identities to be removed from  a Governance Group members list.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteWorkgroupMembers: function (workgroupId, bulkWorkgroupMembersRequestInnerBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.deleteWorkgroupMembers(workgroupId, bulkWorkgroupMembersRequestInnerBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         *  This API initiates a bulk deletion of one or more Governance Groups.  >  If any of the indicated Governance Groups have one or more connections associated with it,then those Governance Groups will be added in  **inUse** list of the response. Governance Group(s) marked as **inUse** can not be deleted.  >  If any of the indicated Governance Groups is not does not exists in Organization,then those Governance Groups will be added in **notFound** list of the response. Governance Groups marked as **notFound** will not be deleted.  >  If any of the indicated Governance Groups does not have any connections associated with it,then those Governance Groups will be added in **deleted** list of the response. A Governance Group marked as **deleted** will be deleted from current Organization.  >  If the request contains any **inUse** or **notFound** Governance Group IDs then it skips only these Governance Groups for deletion and deletes the rest of Governance Groups which have no connections associated with it.   >  **This API has limit number of Governance Groups can be deleted at one time. If the request contains more then 100 Governance Groups IDs to be deleted then the API will throw an exception.**
		         * @summary Delete Governance Group(s)
		         * @param {WorkgroupBulkDeleteRequestBeta} workgroupBulkDeleteRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteWorkgroupsInBulk: function (workgroupBulkDeleteRequestBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.deleteWorkgroupsInBulk(workgroupBulkDeleteRequestBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns a Governance Groups by its ID.
		         * @summary Get Governance Group by Id
		         * @param {string} id ID of the Governance Group
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getWorkgroup: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getWorkgroup(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns list of connections associated with a Governance Group.
		         * @summary List connections for Governance Group
		         * @param {string} workgroupId ID of the Governance Group.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Note that for this API the maximum value for limit is 50. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name, created, modified**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listConnections: function (workgroupId, offset, limit, count, sorters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listConnections(workgroupId, offset, limit, count, sorters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns list of members associated with a Governance Group.
		         * @summary List Governance Group Members
		         * @param {string} workgroupId ID of the Governance Group.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Note that for this API the maximum value for limit is 50. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name, created, modified**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listWorkgroupMembers: function (workgroupId, offset, limit, count, sorters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listWorkgroupMembers(workgroupId, offset, limit, count, sorters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns list of Governance Groups
		         * @summary List Governance Groups
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Note that for this API the maximum value for limit is 50. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in, sw*  **name**: *eq, sw, in*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name, created, modified, id, description**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listWorkgroups: function (offset, limit, count, filters, sorters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listWorkgroups(offset, limit, count, filters, sorters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API updates an existing governance group by ID.  The following fields and objects are patchable:   * name   * description   * owner  A token with API or ORG_ADMIN authority is required to call this API.
		         * @summary Patch a Governance Group
		         * @param {string} id ID of the Governance Group
		         * @param {Array<JsonPatchOperationBeta>} [jsonPatchOperationBeta]
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchWorkgroup: function (id, jsonPatchOperationBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.patchWorkgroup(id, jsonPatchOperationBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API adds one or more members to a Governance Group.  A token with API, ORG_ADMIN authority is required to call this API.  >  **Following field of Identity is an optional field in the request.**  >  **name**
		         * @summary Add members to Governance Group
		         * @param {string} workgroupId ID of the Governance Group.
		         * @param {Array<BulkWorkgroupMembersRequestInnerBeta>} bulkWorkgroupMembersRequestInnerBeta List of identities to be added to a Governance Group members list.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateWorkgroupMembers: function (workgroupId, bulkWorkgroupMembersRequestInnerBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.updateWorkgroupMembers(workgroupId, bulkWorkgroupMembersRequestInnerBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.GovernanceGroupsBetaApiFp = GovernanceGroupsBetaApiFp;
		/**
		 * GovernanceGroupsBetaApi - factory interface
		 * @export
		 */
		var GovernanceGroupsBetaApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.GovernanceGroupsBetaApiFp)(configuration);
		    return {
		        /**
		         * This API creates a new Governance Group.
		         * @summary Create a new Governance Group.
		         * @param {WorkgroupDtoBeta} workgroupDtoBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createWorkgroup: function (workgroupDtoBeta, axiosOptions) {
		            return localVarFp.createWorkgroup(workgroupDtoBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API deletes a Governance Group by its ID.
		         * @summary Delete a Governance Group
		         * @param {string} id ID of the Governance Group
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteWorkgroup: function (id, axiosOptions) {
		            return localVarFp.deleteWorkgroup(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API removes one or more  members from a Governance Group.  A token with API, ORG_ADMIN authority is required to call this API.  >  **Following field of Identity is an optional field in the request.**  >  **name**
		         * @summary Remove members from Governance Group
		         * @param {string} workgroupId ID of the Governance Group.
		         * @param {Array<BulkWorkgroupMembersRequestInnerBeta>} bulkWorkgroupMembersRequestInnerBeta List of identities to be removed from  a Governance Group members list.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteWorkgroupMembers: function (workgroupId, bulkWorkgroupMembersRequestInnerBeta, axiosOptions) {
		            return localVarFp.deleteWorkgroupMembers(workgroupId, bulkWorkgroupMembersRequestInnerBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         *  This API initiates a bulk deletion of one or more Governance Groups.  >  If any of the indicated Governance Groups have one or more connections associated with it,then those Governance Groups will be added in  **inUse** list of the response. Governance Group(s) marked as **inUse** can not be deleted.  >  If any of the indicated Governance Groups is not does not exists in Organization,then those Governance Groups will be added in **notFound** list of the response. Governance Groups marked as **notFound** will not be deleted.  >  If any of the indicated Governance Groups does not have any connections associated with it,then those Governance Groups will be added in **deleted** list of the response. A Governance Group marked as **deleted** will be deleted from current Organization.  >  If the request contains any **inUse** or **notFound** Governance Group IDs then it skips only these Governance Groups for deletion and deletes the rest of Governance Groups which have no connections associated with it.   >  **This API has limit number of Governance Groups can be deleted at one time. If the request contains more then 100 Governance Groups IDs to be deleted then the API will throw an exception.**
		         * @summary Delete Governance Group(s)
		         * @param {WorkgroupBulkDeleteRequestBeta} workgroupBulkDeleteRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteWorkgroupsInBulk: function (workgroupBulkDeleteRequestBeta, axiosOptions) {
		            return localVarFp.deleteWorkgroupsInBulk(workgroupBulkDeleteRequestBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API returns a Governance Groups by its ID.
		         * @summary Get Governance Group by Id
		         * @param {string} id ID of the Governance Group
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getWorkgroup: function (id, axiosOptions) {
		            return localVarFp.getWorkgroup(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API returns list of connections associated with a Governance Group.
		         * @summary List connections for Governance Group
		         * @param {string} workgroupId ID of the Governance Group.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Note that for this API the maximum value for limit is 50. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name, created, modified**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listConnections: function (workgroupId, offset, limit, count, sorters, axiosOptions) {
		            return localVarFp.listConnections(workgroupId, offset, limit, count, sorters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API returns list of members associated with a Governance Group.
		         * @summary List Governance Group Members
		         * @param {string} workgroupId ID of the Governance Group.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Note that for this API the maximum value for limit is 50. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name, created, modified**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listWorkgroupMembers: function (workgroupId, offset, limit, count, sorters, axiosOptions) {
		            return localVarFp.listWorkgroupMembers(workgroupId, offset, limit, count, sorters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API returns list of Governance Groups
		         * @summary List Governance Groups
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Note that for this API the maximum value for limit is 50. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in, sw*  **name**: *eq, sw, in*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name, created, modified, id, description**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listWorkgroups: function (offset, limit, count, filters, sorters, axiosOptions) {
		            return localVarFp.listWorkgroups(offset, limit, count, filters, sorters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API updates an existing governance group by ID.  The following fields and objects are patchable:   * name   * description   * owner  A token with API or ORG_ADMIN authority is required to call this API.
		         * @summary Patch a Governance Group
		         * @param {string} id ID of the Governance Group
		         * @param {Array<JsonPatchOperationBeta>} [jsonPatchOperationBeta]
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchWorkgroup: function (id, jsonPatchOperationBeta, axiosOptions) {
		            return localVarFp.patchWorkgroup(id, jsonPatchOperationBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API adds one or more members to a Governance Group.  A token with API, ORG_ADMIN authority is required to call this API.  >  **Following field of Identity is an optional field in the request.**  >  **name**
		         * @summary Add members to Governance Group
		         * @param {string} workgroupId ID of the Governance Group.
		         * @param {Array<BulkWorkgroupMembersRequestInnerBeta>} bulkWorkgroupMembersRequestInnerBeta List of identities to be added to a Governance Group members list.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateWorkgroupMembers: function (workgroupId, bulkWorkgroupMembersRequestInnerBeta, axiosOptions) {
		            return localVarFp.updateWorkgroupMembers(workgroupId, bulkWorkgroupMembersRequestInnerBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.GovernanceGroupsBetaApiFactory = GovernanceGroupsBetaApiFactory;
		/**
		 * GovernanceGroupsBetaApi - object-oriented interface
		 * @export
		 * @class GovernanceGroupsBetaApi
		 * @extends {BaseAPI}
		 */
		var GovernanceGroupsBetaApi = /** @class */ (function (_super) {
		    __extends(GovernanceGroupsBetaApi, _super);
		    function GovernanceGroupsBetaApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * This API creates a new Governance Group.
		     * @summary Create a new Governance Group.
		     * @param {GovernanceGroupsBetaApiCreateWorkgroupRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof GovernanceGroupsBetaApi
		     */
		    GovernanceGroupsBetaApi.prototype.createWorkgroup = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.GovernanceGroupsBetaApiFp)(this.configuration).createWorkgroup(requestParameters.workgroupDtoBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API deletes a Governance Group by its ID.
		     * @summary Delete a Governance Group
		     * @param {GovernanceGroupsBetaApiDeleteWorkgroupRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof GovernanceGroupsBetaApi
		     */
		    GovernanceGroupsBetaApi.prototype.deleteWorkgroup = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.GovernanceGroupsBetaApiFp)(this.configuration).deleteWorkgroup(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API removes one or more  members from a Governance Group.  A token with API, ORG_ADMIN authority is required to call this API.  >  **Following field of Identity is an optional field in the request.**  >  **name**
		     * @summary Remove members from Governance Group
		     * @param {GovernanceGroupsBetaApiDeleteWorkgroupMembersRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof GovernanceGroupsBetaApi
		     */
		    GovernanceGroupsBetaApi.prototype.deleteWorkgroupMembers = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.GovernanceGroupsBetaApiFp)(this.configuration).deleteWorkgroupMembers(requestParameters.workgroupId, requestParameters.bulkWorkgroupMembersRequestInnerBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     *  This API initiates a bulk deletion of one or more Governance Groups.  >  If any of the indicated Governance Groups have one or more connections associated with it,then those Governance Groups will be added in  **inUse** list of the response. Governance Group(s) marked as **inUse** can not be deleted.  >  If any of the indicated Governance Groups is not does not exists in Organization,then those Governance Groups will be added in **notFound** list of the response. Governance Groups marked as **notFound** will not be deleted.  >  If any of the indicated Governance Groups does not have any connections associated with it,then those Governance Groups will be added in **deleted** list of the response. A Governance Group marked as **deleted** will be deleted from current Organization.  >  If the request contains any **inUse** or **notFound** Governance Group IDs then it skips only these Governance Groups for deletion and deletes the rest of Governance Groups which have no connections associated with it.   >  **This API has limit number of Governance Groups can be deleted at one time. If the request contains more then 100 Governance Groups IDs to be deleted then the API will throw an exception.**
		     * @summary Delete Governance Group(s)
		     * @param {GovernanceGroupsBetaApiDeleteWorkgroupsInBulkRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof GovernanceGroupsBetaApi
		     */
		    GovernanceGroupsBetaApi.prototype.deleteWorkgroupsInBulk = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.GovernanceGroupsBetaApiFp)(this.configuration).deleteWorkgroupsInBulk(requestParameters.workgroupBulkDeleteRequestBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API returns a Governance Groups by its ID.
		     * @summary Get Governance Group by Id
		     * @param {GovernanceGroupsBetaApiGetWorkgroupRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof GovernanceGroupsBetaApi
		     */
		    GovernanceGroupsBetaApi.prototype.getWorkgroup = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.GovernanceGroupsBetaApiFp)(this.configuration).getWorkgroup(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API returns list of connections associated with a Governance Group.
		     * @summary List connections for Governance Group
		     * @param {GovernanceGroupsBetaApiListConnectionsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof GovernanceGroupsBetaApi
		     */
		    GovernanceGroupsBetaApi.prototype.listConnections = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.GovernanceGroupsBetaApiFp)(this.configuration).listConnections(requestParameters.workgroupId, requestParameters.offset, requestParameters.limit, requestParameters.count, requestParameters.sorters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API returns list of members associated with a Governance Group.
		     * @summary List Governance Group Members
		     * @param {GovernanceGroupsBetaApiListWorkgroupMembersRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof GovernanceGroupsBetaApi
		     */
		    GovernanceGroupsBetaApi.prototype.listWorkgroupMembers = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.GovernanceGroupsBetaApiFp)(this.configuration).listWorkgroupMembers(requestParameters.workgroupId, requestParameters.offset, requestParameters.limit, requestParameters.count, requestParameters.sorters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API returns list of Governance Groups
		     * @summary List Governance Groups
		     * @param {GovernanceGroupsBetaApiListWorkgroupsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof GovernanceGroupsBetaApi
		     */
		    GovernanceGroupsBetaApi.prototype.listWorkgroups = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.GovernanceGroupsBetaApiFp)(this.configuration).listWorkgroups(requestParameters.offset, requestParameters.limit, requestParameters.count, requestParameters.filters, requestParameters.sorters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API updates an existing governance group by ID.  The following fields and objects are patchable:   * name   * description   * owner  A token with API or ORG_ADMIN authority is required to call this API.
		     * @summary Patch a Governance Group
		     * @param {GovernanceGroupsBetaApiPatchWorkgroupRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof GovernanceGroupsBetaApi
		     */
		    GovernanceGroupsBetaApi.prototype.patchWorkgroup = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.GovernanceGroupsBetaApiFp)(this.configuration).patchWorkgroup(requestParameters.id, requestParameters.jsonPatchOperationBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API adds one or more members to a Governance Group.  A token with API, ORG_ADMIN authority is required to call this API.  >  **Following field of Identity is an optional field in the request.**  >  **name**
		     * @summary Add members to Governance Group
		     * @param {GovernanceGroupsBetaApiUpdateWorkgroupMembersRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof GovernanceGroupsBetaApi
		     */
		    GovernanceGroupsBetaApi.prototype.updateWorkgroupMembers = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.GovernanceGroupsBetaApiFp)(this.configuration).updateWorkgroupMembers(requestParameters.workgroupId, requestParameters.bulkWorkgroupMembersRequestInnerBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return GovernanceGroupsBetaApi;
		}(base_1.BaseAPI));
		exports.GovernanceGroupsBetaApi = GovernanceGroupsBetaApi;
		/**
		 * IAIAccessRequestRecommendationsBetaApi - axios parameter creator
		 * @export
		 */
		var IAIAccessRequestRecommendationsBetaApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * This API ignores a recommended access request item. Once an item is ignored, it will be marked as ignored=true if it is still a recommended item. The consumer can decide to hide ignored recommendations.
		         * @summary Notification of Ignored Access Request Recommendations
		         * @param {AccessRequestRecommendationActionItemDtoBeta} accessRequestRecommendationActionItemDtoBeta The recommended access item to ignore for an identity.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        addAccessRequestRecommendationsIgnoredItem: function (accessRequestRecommendationActionItemDtoBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'accessRequestRecommendationActionItemDtoBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('addAccessRequestRecommendationsIgnoredItem', 'accessRequestRecommendationActionItemDtoBeta', accessRequestRecommendationActionItemDtoBeta);
		                            localVarPath = "/ai-access-request-recommendations/ignored-items";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(accessRequestRecommendationActionItemDtoBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API consumes a notification that a recommended access request item was requested. This API does not actually make the request, it is just a notification. This will help provide feedback in order to improve our recommendations.
		         * @summary Notification of Requested Access Request Recommendations
		         * @param {AccessRequestRecommendationActionItemDtoBeta} accessRequestRecommendationActionItemDtoBeta The recommended access item that was requested for an identity.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        addAccessRequestRecommendationsRequestedItem: function (accessRequestRecommendationActionItemDtoBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'accessRequestRecommendationActionItemDtoBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('addAccessRequestRecommendationsRequestedItem', 'accessRequestRecommendationActionItemDtoBeta', accessRequestRecommendationActionItemDtoBeta);
		                            localVarPath = "/ai-access-request-recommendations/requested-items";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(accessRequestRecommendationActionItemDtoBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API consumes a notification that a recommended access request item was viewed. Future recommendations with this item will be marked with viewed=true. This can be useful for the consumer to determine if there are any new/unviewed recommendations.
		         * @summary Notification of Viewed Access Request Recommendations
		         * @param {AccessRequestRecommendationActionItemDtoBeta} accessRequestRecommendationActionItemDtoBeta The recommended access that was viewed for an identity.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        addAccessRequestRecommendationsViewedItem: function (accessRequestRecommendationActionItemDtoBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'accessRequestRecommendationActionItemDtoBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('addAccessRequestRecommendationsViewedItem', 'accessRequestRecommendationActionItemDtoBeta', accessRequestRecommendationActionItemDtoBeta);
		                            localVarPath = "/ai-access-request-recommendations/viewed-items";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(accessRequestRecommendationActionItemDtoBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API consumes a notification that a set of recommended access request item were viewed. Future recommendations with these items will be marked with viewed=true. This can be useful for the consumer to determine if there are any new/unviewed recommendations.
		         * @summary Notification of Viewed Access Request Recommendations in Bulk
		         * @param {Array<AccessRequestRecommendationActionItemDtoBeta>} accessRequestRecommendationActionItemDtoBeta The recommended access items that were viewed for an identity.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        addAccessRequestRecommendationsViewedItems: function (accessRequestRecommendationActionItemDtoBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'accessRequestRecommendationActionItemDtoBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('addAccessRequestRecommendationsViewedItems', 'accessRequestRecommendationActionItemDtoBeta', accessRequestRecommendationActionItemDtoBeta);
		                            localVarPath = "/ai-access-request-recommendations/viewed-items/bulk-create";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(accessRequestRecommendationActionItemDtoBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns the access request recommendations for the specified identity. The default identity is *me* which indicates the current user.
		         * @summary Identity Access Request Recommendations
		         * @param {string} [identityId] Get access request recommendations for an identityId. *me* indicates the current user.
		         * @param {number} [limit] Max number of results to return.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [includeTranslationMessages] If *true* it will populate a list of translation messages in the response.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **access.name**: *co*  **access.type**: *eq, in*  **access.description**: *co, eq, in*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **access.name, access.type**  By default the recommendations are sorted by highest confidence first.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getAccessRequestRecommendations: function (identityId, limit, offset, count, includeTranslationMessages, filters, sorters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/ai-access-request-recommendations";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (identityId !== undefined) {
		                                localVarQueryParameter['identity-id'] = identityId;
		                            }
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (includeTranslationMessages !== undefined) {
		                                localVarQueryParameter['include-translation-messages'] = includeTranslationMessages;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns the list of ignored access request recommendations.
		         * @summary List of Ignored Access Request Recommendations
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **access.id**: *eq, in*  **access.type**: *eq, in*  **identityId**: *eq, in*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **access.id, access.type, identityId, timestamp**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getAccessRequestRecommendationsIgnoredItems: function (limit, offset, count, filters, sorters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/ai-access-request-recommendations/ignored-items";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns a list of requested access request recommendations.
		         * @summary List of Requested Access Request Recommendations
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **access.id**: *eq, in*  **access.type**: *eq, in*  **identityId**: *eq, in*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **access.id, access.type, identityId, timestamp**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getAccessRequestRecommendationsRequestedItems: function (limit, offset, count, filters, sorters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/ai-access-request-recommendations/requested-items";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns the list of viewed access request recommendations.
		         * @summary List of Viewed Access Request Recommendations
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **access.id**: *eq, in*  **access.type**: *eq, in*  **identityId**: *eq, in*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **access.id, access.type, identityId, timestamp**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getAccessRequestRecommendationsViewedItems: function (limit, offset, count, filters, sorters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/ai-access-request-recommendations/viewed-items";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.IAIAccessRequestRecommendationsBetaApiAxiosParamCreator = IAIAccessRequestRecommendationsBetaApiAxiosParamCreator;
		/**
		 * IAIAccessRequestRecommendationsBetaApi - functional programming interface
		 * @export
		 */
		var IAIAccessRequestRecommendationsBetaApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.IAIAccessRequestRecommendationsBetaApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * This API ignores a recommended access request item. Once an item is ignored, it will be marked as ignored=true if it is still a recommended item. The consumer can decide to hide ignored recommendations.
		         * @summary Notification of Ignored Access Request Recommendations
		         * @param {AccessRequestRecommendationActionItemDtoBeta} accessRequestRecommendationActionItemDtoBeta The recommended access item to ignore for an identity.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        addAccessRequestRecommendationsIgnoredItem: function (accessRequestRecommendationActionItemDtoBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.addAccessRequestRecommendationsIgnoredItem(accessRequestRecommendationActionItemDtoBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API consumes a notification that a recommended access request item was requested. This API does not actually make the request, it is just a notification. This will help provide feedback in order to improve our recommendations.
		         * @summary Notification of Requested Access Request Recommendations
		         * @param {AccessRequestRecommendationActionItemDtoBeta} accessRequestRecommendationActionItemDtoBeta The recommended access item that was requested for an identity.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        addAccessRequestRecommendationsRequestedItem: function (accessRequestRecommendationActionItemDtoBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.addAccessRequestRecommendationsRequestedItem(accessRequestRecommendationActionItemDtoBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API consumes a notification that a recommended access request item was viewed. Future recommendations with this item will be marked with viewed=true. This can be useful for the consumer to determine if there are any new/unviewed recommendations.
		         * @summary Notification of Viewed Access Request Recommendations
		         * @param {AccessRequestRecommendationActionItemDtoBeta} accessRequestRecommendationActionItemDtoBeta The recommended access that was viewed for an identity.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        addAccessRequestRecommendationsViewedItem: function (accessRequestRecommendationActionItemDtoBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.addAccessRequestRecommendationsViewedItem(accessRequestRecommendationActionItemDtoBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API consumes a notification that a set of recommended access request item were viewed. Future recommendations with these items will be marked with viewed=true. This can be useful for the consumer to determine if there are any new/unviewed recommendations.
		         * @summary Notification of Viewed Access Request Recommendations in Bulk
		         * @param {Array<AccessRequestRecommendationActionItemDtoBeta>} accessRequestRecommendationActionItemDtoBeta The recommended access items that were viewed for an identity.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        addAccessRequestRecommendationsViewedItems: function (accessRequestRecommendationActionItemDtoBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.addAccessRequestRecommendationsViewedItems(accessRequestRecommendationActionItemDtoBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns the access request recommendations for the specified identity. The default identity is *me* which indicates the current user.
		         * @summary Identity Access Request Recommendations
		         * @param {string} [identityId] Get access request recommendations for an identityId. *me* indicates the current user.
		         * @param {number} [limit] Max number of results to return.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [includeTranslationMessages] If *true* it will populate a list of translation messages in the response.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **access.name**: *co*  **access.type**: *eq, in*  **access.description**: *co, eq, in*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **access.name, access.type**  By default the recommendations are sorted by highest confidence first.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getAccessRequestRecommendations: function (identityId, limit, offset, count, includeTranslationMessages, filters, sorters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getAccessRequestRecommendations(identityId, limit, offset, count, includeTranslationMessages, filters, sorters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns the list of ignored access request recommendations.
		         * @summary List of Ignored Access Request Recommendations
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **access.id**: *eq, in*  **access.type**: *eq, in*  **identityId**: *eq, in*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **access.id, access.type, identityId, timestamp**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getAccessRequestRecommendationsIgnoredItems: function (limit, offset, count, filters, sorters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getAccessRequestRecommendationsIgnoredItems(limit, offset, count, filters, sorters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns a list of requested access request recommendations.
		         * @summary List of Requested Access Request Recommendations
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **access.id**: *eq, in*  **access.type**: *eq, in*  **identityId**: *eq, in*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **access.id, access.type, identityId, timestamp**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getAccessRequestRecommendationsRequestedItems: function (limit, offset, count, filters, sorters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getAccessRequestRecommendationsRequestedItems(limit, offset, count, filters, sorters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns the list of viewed access request recommendations.
		         * @summary List of Viewed Access Request Recommendations
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **access.id**: *eq, in*  **access.type**: *eq, in*  **identityId**: *eq, in*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **access.id, access.type, identityId, timestamp**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getAccessRequestRecommendationsViewedItems: function (limit, offset, count, filters, sorters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getAccessRequestRecommendationsViewedItems(limit, offset, count, filters, sorters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.IAIAccessRequestRecommendationsBetaApiFp = IAIAccessRequestRecommendationsBetaApiFp;
		/**
		 * IAIAccessRequestRecommendationsBetaApi - factory interface
		 * @export
		 */
		var IAIAccessRequestRecommendationsBetaApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.IAIAccessRequestRecommendationsBetaApiFp)(configuration);
		    return {
		        /**
		         * This API ignores a recommended access request item. Once an item is ignored, it will be marked as ignored=true if it is still a recommended item. The consumer can decide to hide ignored recommendations.
		         * @summary Notification of Ignored Access Request Recommendations
		         * @param {AccessRequestRecommendationActionItemDtoBeta} accessRequestRecommendationActionItemDtoBeta The recommended access item to ignore for an identity.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        addAccessRequestRecommendationsIgnoredItem: function (accessRequestRecommendationActionItemDtoBeta, axiosOptions) {
		            return localVarFp.addAccessRequestRecommendationsIgnoredItem(accessRequestRecommendationActionItemDtoBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API consumes a notification that a recommended access request item was requested. This API does not actually make the request, it is just a notification. This will help provide feedback in order to improve our recommendations.
		         * @summary Notification of Requested Access Request Recommendations
		         * @param {AccessRequestRecommendationActionItemDtoBeta} accessRequestRecommendationActionItemDtoBeta The recommended access item that was requested for an identity.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        addAccessRequestRecommendationsRequestedItem: function (accessRequestRecommendationActionItemDtoBeta, axiosOptions) {
		            return localVarFp.addAccessRequestRecommendationsRequestedItem(accessRequestRecommendationActionItemDtoBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API consumes a notification that a recommended access request item was viewed. Future recommendations with this item will be marked with viewed=true. This can be useful for the consumer to determine if there are any new/unviewed recommendations.
		         * @summary Notification of Viewed Access Request Recommendations
		         * @param {AccessRequestRecommendationActionItemDtoBeta} accessRequestRecommendationActionItemDtoBeta The recommended access that was viewed for an identity.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        addAccessRequestRecommendationsViewedItem: function (accessRequestRecommendationActionItemDtoBeta, axiosOptions) {
		            return localVarFp.addAccessRequestRecommendationsViewedItem(accessRequestRecommendationActionItemDtoBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API consumes a notification that a set of recommended access request item were viewed. Future recommendations with these items will be marked with viewed=true. This can be useful for the consumer to determine if there are any new/unviewed recommendations.
		         * @summary Notification of Viewed Access Request Recommendations in Bulk
		         * @param {Array<AccessRequestRecommendationActionItemDtoBeta>} accessRequestRecommendationActionItemDtoBeta The recommended access items that were viewed for an identity.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        addAccessRequestRecommendationsViewedItems: function (accessRequestRecommendationActionItemDtoBeta, axiosOptions) {
		            return localVarFp.addAccessRequestRecommendationsViewedItems(accessRequestRecommendationActionItemDtoBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API returns the access request recommendations for the specified identity. The default identity is *me* which indicates the current user.
		         * @summary Identity Access Request Recommendations
		         * @param {string} [identityId] Get access request recommendations for an identityId. *me* indicates the current user.
		         * @param {number} [limit] Max number of results to return.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [includeTranslationMessages] If *true* it will populate a list of translation messages in the response.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **access.name**: *co*  **access.type**: *eq, in*  **access.description**: *co, eq, in*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **access.name, access.type**  By default the recommendations are sorted by highest confidence first.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getAccessRequestRecommendations: function (identityId, limit, offset, count, includeTranslationMessages, filters, sorters, axiosOptions) {
		            return localVarFp.getAccessRequestRecommendations(identityId, limit, offset, count, includeTranslationMessages, filters, sorters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API returns the list of ignored access request recommendations.
		         * @summary List of Ignored Access Request Recommendations
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **access.id**: *eq, in*  **access.type**: *eq, in*  **identityId**: *eq, in*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **access.id, access.type, identityId, timestamp**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getAccessRequestRecommendationsIgnoredItems: function (limit, offset, count, filters, sorters, axiosOptions) {
		            return localVarFp.getAccessRequestRecommendationsIgnoredItems(limit, offset, count, filters, sorters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API returns a list of requested access request recommendations.
		         * @summary List of Requested Access Request Recommendations
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **access.id**: *eq, in*  **access.type**: *eq, in*  **identityId**: *eq, in*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **access.id, access.type, identityId, timestamp**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getAccessRequestRecommendationsRequestedItems: function (limit, offset, count, filters, sorters, axiosOptions) {
		            return localVarFp.getAccessRequestRecommendationsRequestedItems(limit, offset, count, filters, sorters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API returns the list of viewed access request recommendations.
		         * @summary List of Viewed Access Request Recommendations
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **access.id**: *eq, in*  **access.type**: *eq, in*  **identityId**: *eq, in*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **access.id, access.type, identityId, timestamp**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getAccessRequestRecommendationsViewedItems: function (limit, offset, count, filters, sorters, axiosOptions) {
		            return localVarFp.getAccessRequestRecommendationsViewedItems(limit, offset, count, filters, sorters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.IAIAccessRequestRecommendationsBetaApiFactory = IAIAccessRequestRecommendationsBetaApiFactory;
		/**
		 * IAIAccessRequestRecommendationsBetaApi - object-oriented interface
		 * @export
		 * @class IAIAccessRequestRecommendationsBetaApi
		 * @extends {BaseAPI}
		 */
		var IAIAccessRequestRecommendationsBetaApi = /** @class */ (function (_super) {
		    __extends(IAIAccessRequestRecommendationsBetaApi, _super);
		    function IAIAccessRequestRecommendationsBetaApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * This API ignores a recommended access request item. Once an item is ignored, it will be marked as ignored=true if it is still a recommended item. The consumer can decide to hide ignored recommendations.
		     * @summary Notification of Ignored Access Request Recommendations
		     * @param {IAIAccessRequestRecommendationsBetaApiAddAccessRequestRecommendationsIgnoredItemRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IAIAccessRequestRecommendationsBetaApi
		     */
		    IAIAccessRequestRecommendationsBetaApi.prototype.addAccessRequestRecommendationsIgnoredItem = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.IAIAccessRequestRecommendationsBetaApiFp)(this.configuration).addAccessRequestRecommendationsIgnoredItem(requestParameters.accessRequestRecommendationActionItemDtoBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API consumes a notification that a recommended access request item was requested. This API does not actually make the request, it is just a notification. This will help provide feedback in order to improve our recommendations.
		     * @summary Notification of Requested Access Request Recommendations
		     * @param {IAIAccessRequestRecommendationsBetaApiAddAccessRequestRecommendationsRequestedItemRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IAIAccessRequestRecommendationsBetaApi
		     */
		    IAIAccessRequestRecommendationsBetaApi.prototype.addAccessRequestRecommendationsRequestedItem = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.IAIAccessRequestRecommendationsBetaApiFp)(this.configuration).addAccessRequestRecommendationsRequestedItem(requestParameters.accessRequestRecommendationActionItemDtoBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API consumes a notification that a recommended access request item was viewed. Future recommendations with this item will be marked with viewed=true. This can be useful for the consumer to determine if there are any new/unviewed recommendations.
		     * @summary Notification of Viewed Access Request Recommendations
		     * @param {IAIAccessRequestRecommendationsBetaApiAddAccessRequestRecommendationsViewedItemRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IAIAccessRequestRecommendationsBetaApi
		     */
		    IAIAccessRequestRecommendationsBetaApi.prototype.addAccessRequestRecommendationsViewedItem = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.IAIAccessRequestRecommendationsBetaApiFp)(this.configuration).addAccessRequestRecommendationsViewedItem(requestParameters.accessRequestRecommendationActionItemDtoBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API consumes a notification that a set of recommended access request item were viewed. Future recommendations with these items will be marked with viewed=true. This can be useful for the consumer to determine if there are any new/unviewed recommendations.
		     * @summary Notification of Viewed Access Request Recommendations in Bulk
		     * @param {IAIAccessRequestRecommendationsBetaApiAddAccessRequestRecommendationsViewedItemsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IAIAccessRequestRecommendationsBetaApi
		     */
		    IAIAccessRequestRecommendationsBetaApi.prototype.addAccessRequestRecommendationsViewedItems = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.IAIAccessRequestRecommendationsBetaApiFp)(this.configuration).addAccessRequestRecommendationsViewedItems(requestParameters.accessRequestRecommendationActionItemDtoBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API returns the access request recommendations for the specified identity. The default identity is *me* which indicates the current user.
		     * @summary Identity Access Request Recommendations
		     * @param {IAIAccessRequestRecommendationsBetaApiGetAccessRequestRecommendationsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IAIAccessRequestRecommendationsBetaApi
		     */
		    IAIAccessRequestRecommendationsBetaApi.prototype.getAccessRequestRecommendations = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.IAIAccessRequestRecommendationsBetaApiFp)(this.configuration).getAccessRequestRecommendations(requestParameters.identityId, requestParameters.limit, requestParameters.offset, requestParameters.count, requestParameters.includeTranslationMessages, requestParameters.filters, requestParameters.sorters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API returns the list of ignored access request recommendations.
		     * @summary List of Ignored Access Request Recommendations
		     * @param {IAIAccessRequestRecommendationsBetaApiGetAccessRequestRecommendationsIgnoredItemsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IAIAccessRequestRecommendationsBetaApi
		     */
		    IAIAccessRequestRecommendationsBetaApi.prototype.getAccessRequestRecommendationsIgnoredItems = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.IAIAccessRequestRecommendationsBetaApiFp)(this.configuration).getAccessRequestRecommendationsIgnoredItems(requestParameters.limit, requestParameters.offset, requestParameters.count, requestParameters.filters, requestParameters.sorters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API returns a list of requested access request recommendations.
		     * @summary List of Requested Access Request Recommendations
		     * @param {IAIAccessRequestRecommendationsBetaApiGetAccessRequestRecommendationsRequestedItemsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IAIAccessRequestRecommendationsBetaApi
		     */
		    IAIAccessRequestRecommendationsBetaApi.prototype.getAccessRequestRecommendationsRequestedItems = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.IAIAccessRequestRecommendationsBetaApiFp)(this.configuration).getAccessRequestRecommendationsRequestedItems(requestParameters.limit, requestParameters.offset, requestParameters.count, requestParameters.filters, requestParameters.sorters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API returns the list of viewed access request recommendations.
		     * @summary List of Viewed Access Request Recommendations
		     * @param {IAIAccessRequestRecommendationsBetaApiGetAccessRequestRecommendationsViewedItemsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IAIAccessRequestRecommendationsBetaApi
		     */
		    IAIAccessRequestRecommendationsBetaApi.prototype.getAccessRequestRecommendationsViewedItems = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.IAIAccessRequestRecommendationsBetaApiFp)(this.configuration).getAccessRequestRecommendationsViewedItems(requestParameters.limit, requestParameters.offset, requestParameters.count, requestParameters.filters, requestParameters.sorters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return IAIAccessRequestRecommendationsBetaApi;
		}(base_1.BaseAPI));
		exports.IAIAccessRequestRecommendationsBetaApi = IAIAccessRequestRecommendationsBetaApi;
		/**
		 * IAICommonAccessBetaApi - axios parameter creator
		 * @export
		 */
		var IAICommonAccessBetaApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * This API is used to add roles/access profiles to the list of common access for a customer. Requires authorization scope of iai:access-modeling:create
		         * @summary Create common access items
		         * @param {CommonAccessItemRequestBeta} commonAccessItemRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createCommonAccess: function (commonAccessItemRequestBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'commonAccessItemRequestBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('createCommonAccess', 'commonAccessItemRequestBeta', commonAccessItemRequestBeta);
		                            localVarPath = "/common-access";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(commonAccessItemRequestBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This endpoint returns the current common access for a customer. The returned items can be filtered and sorted. Requires authorization scope of iai:access-modeling:read
		         * @summary Get a paginated list of common access
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **status**: *eq, sw*  **reviewedByUser** *eq*  **access.id**: *eq, sw*  **access.type**: *eq*  **access.name**: *sw, eq*  **access.description**: *sw, eq*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **access.name, status**  By default the common access items are sorted by name, ascending.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getCommonAccess: function (offset, limit, count, filters, sorters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/common-access";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This submits an update request to the common access application. At this time there are no parameters. Requires authorization scope of iai:access-modeling:update
		         * @summary Bulk update common access status
		         * @param {Array<CommonAccessIDStatusBeta>} commonAccessIDStatusBeta Confirm or deny in bulk the common access ids that are (or aren\&#39;t) common access
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateCommonAccessStatusInBulk: function (commonAccessIDStatusBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'commonAccessIDStatusBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('updateCommonAccessStatusInBulk', 'commonAccessIDStatusBeta', commonAccessIDStatusBeta);
		                            localVarPath = "/common-access/update-status";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(commonAccessIDStatusBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.IAICommonAccessBetaApiAxiosParamCreator = IAICommonAccessBetaApiAxiosParamCreator;
		/**
		 * IAICommonAccessBetaApi - functional programming interface
		 * @export
		 */
		var IAICommonAccessBetaApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.IAICommonAccessBetaApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * This API is used to add roles/access profiles to the list of common access for a customer. Requires authorization scope of iai:access-modeling:create
		         * @summary Create common access items
		         * @param {CommonAccessItemRequestBeta} commonAccessItemRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createCommonAccess: function (commonAccessItemRequestBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.createCommonAccess(commonAccessItemRequestBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This endpoint returns the current common access for a customer. The returned items can be filtered and sorted. Requires authorization scope of iai:access-modeling:read
		         * @summary Get a paginated list of common access
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **status**: *eq, sw*  **reviewedByUser** *eq*  **access.id**: *eq, sw*  **access.type**: *eq*  **access.name**: *sw, eq*  **access.description**: *sw, eq*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **access.name, status**  By default the common access items are sorted by name, ascending.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getCommonAccess: function (offset, limit, count, filters, sorters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getCommonAccess(offset, limit, count, filters, sorters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This submits an update request to the common access application. At this time there are no parameters. Requires authorization scope of iai:access-modeling:update
		         * @summary Bulk update common access status
		         * @param {Array<CommonAccessIDStatusBeta>} commonAccessIDStatusBeta Confirm or deny in bulk the common access ids that are (or aren\&#39;t) common access
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateCommonAccessStatusInBulk: function (commonAccessIDStatusBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.updateCommonAccessStatusInBulk(commonAccessIDStatusBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.IAICommonAccessBetaApiFp = IAICommonAccessBetaApiFp;
		/**
		 * IAICommonAccessBetaApi - factory interface
		 * @export
		 */
		var IAICommonAccessBetaApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.IAICommonAccessBetaApiFp)(configuration);
		    return {
		        /**
		         * This API is used to add roles/access profiles to the list of common access for a customer. Requires authorization scope of iai:access-modeling:create
		         * @summary Create common access items
		         * @param {CommonAccessItemRequestBeta} commonAccessItemRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createCommonAccess: function (commonAccessItemRequestBeta, axiosOptions) {
		            return localVarFp.createCommonAccess(commonAccessItemRequestBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This endpoint returns the current common access for a customer. The returned items can be filtered and sorted. Requires authorization scope of iai:access-modeling:read
		         * @summary Get a paginated list of common access
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **status**: *eq, sw*  **reviewedByUser** *eq*  **access.id**: *eq, sw*  **access.type**: *eq*  **access.name**: *sw, eq*  **access.description**: *sw, eq*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **access.name, status**  By default the common access items are sorted by name, ascending.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getCommonAccess: function (offset, limit, count, filters, sorters, axiosOptions) {
		            return localVarFp.getCommonAccess(offset, limit, count, filters, sorters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This submits an update request to the common access application. At this time there are no parameters. Requires authorization scope of iai:access-modeling:update
		         * @summary Bulk update common access status
		         * @param {Array<CommonAccessIDStatusBeta>} commonAccessIDStatusBeta Confirm or deny in bulk the common access ids that are (or aren\&#39;t) common access
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateCommonAccessStatusInBulk: function (commonAccessIDStatusBeta, axiosOptions) {
		            return localVarFp.updateCommonAccessStatusInBulk(commonAccessIDStatusBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.IAICommonAccessBetaApiFactory = IAICommonAccessBetaApiFactory;
		/**
		 * IAICommonAccessBetaApi - object-oriented interface
		 * @export
		 * @class IAICommonAccessBetaApi
		 * @extends {BaseAPI}
		 */
		var IAICommonAccessBetaApi = /** @class */ (function (_super) {
		    __extends(IAICommonAccessBetaApi, _super);
		    function IAICommonAccessBetaApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * This API is used to add roles/access profiles to the list of common access for a customer. Requires authorization scope of iai:access-modeling:create
		     * @summary Create common access items
		     * @param {IAICommonAccessBetaApiCreateCommonAccessRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IAICommonAccessBetaApi
		     */
		    IAICommonAccessBetaApi.prototype.createCommonAccess = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.IAICommonAccessBetaApiFp)(this.configuration).createCommonAccess(requestParameters.commonAccessItemRequestBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This endpoint returns the current common access for a customer. The returned items can be filtered and sorted. Requires authorization scope of iai:access-modeling:read
		     * @summary Get a paginated list of common access
		     * @param {IAICommonAccessBetaApiGetCommonAccessRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IAICommonAccessBetaApi
		     */
		    IAICommonAccessBetaApi.prototype.getCommonAccess = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.IAICommonAccessBetaApiFp)(this.configuration).getCommonAccess(requestParameters.offset, requestParameters.limit, requestParameters.count, requestParameters.filters, requestParameters.sorters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This submits an update request to the common access application. At this time there are no parameters. Requires authorization scope of iai:access-modeling:update
		     * @summary Bulk update common access status
		     * @param {IAICommonAccessBetaApiUpdateCommonAccessStatusInBulkRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IAICommonAccessBetaApi
		     */
		    IAICommonAccessBetaApi.prototype.updateCommonAccessStatusInBulk = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.IAICommonAccessBetaApiFp)(this.configuration).updateCommonAccessStatusInBulk(requestParameters.commonAccessIDStatusBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return IAICommonAccessBetaApi;
		}(base_1.BaseAPI));
		exports.IAICommonAccessBetaApi = IAICommonAccessBetaApi;
		/**
		 * IAIMessageCatalogsBetaApi - axios parameter creator
		 * @export
		 */
		var IAIMessageCatalogsBetaApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * The getMessageCatalogs API returns message catalog based on the language headers in the requested object.
		         * @summary Get Message catalogs
		         * @param {'recommender' | 'access-request-recommender'} catalogId The ID of the message catalog.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getMessageCatalogs: function (catalogId, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'catalogId' is not null or undefined
		                            (0, common_1.assertParamExists)('getMessageCatalogs', 'catalogId', catalogId);
		                            localVarPath = "/translation-catalogs/{catalog-id}"
		                                .replace("{".concat("catalog-id", "}"), encodeURIComponent(String(catalogId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.IAIMessageCatalogsBetaApiAxiosParamCreator = IAIMessageCatalogsBetaApiAxiosParamCreator;
		/**
		 * IAIMessageCatalogsBetaApi - functional programming interface
		 * @export
		 */
		var IAIMessageCatalogsBetaApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.IAIMessageCatalogsBetaApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * The getMessageCatalogs API returns message catalog based on the language headers in the requested object.
		         * @summary Get Message catalogs
		         * @param {'recommender' | 'access-request-recommender'} catalogId The ID of the message catalog.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getMessageCatalogs: function (catalogId, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getMessageCatalogs(catalogId, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.IAIMessageCatalogsBetaApiFp = IAIMessageCatalogsBetaApiFp;
		/**
		 * IAIMessageCatalogsBetaApi - factory interface
		 * @export
		 */
		var IAIMessageCatalogsBetaApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.IAIMessageCatalogsBetaApiFp)(configuration);
		    return {
		        /**
		         * The getMessageCatalogs API returns message catalog based on the language headers in the requested object.
		         * @summary Get Message catalogs
		         * @param {'recommender' | 'access-request-recommender'} catalogId The ID of the message catalog.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getMessageCatalogs: function (catalogId, axiosOptions) {
		            return localVarFp.getMessageCatalogs(catalogId, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.IAIMessageCatalogsBetaApiFactory = IAIMessageCatalogsBetaApiFactory;
		/**
		 * IAIMessageCatalogsBetaApi - object-oriented interface
		 * @export
		 * @class IAIMessageCatalogsBetaApi
		 * @extends {BaseAPI}
		 */
		var IAIMessageCatalogsBetaApi = /** @class */ (function (_super) {
		    __extends(IAIMessageCatalogsBetaApi, _super);
		    function IAIMessageCatalogsBetaApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * The getMessageCatalogs API returns message catalog based on the language headers in the requested object.
		     * @summary Get Message catalogs
		     * @param {IAIMessageCatalogsBetaApiGetMessageCatalogsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IAIMessageCatalogsBetaApi
		     */
		    IAIMessageCatalogsBetaApi.prototype.getMessageCatalogs = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.IAIMessageCatalogsBetaApiFp)(this.configuration).getMessageCatalogs(requestParameters.catalogId, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return IAIMessageCatalogsBetaApi;
		}(base_1.BaseAPI));
		exports.IAIMessageCatalogsBetaApi = IAIMessageCatalogsBetaApi;
		/**
		 * IAIOutliersBetaApi - axios parameter creator
		 * @export
		 */
		var IAIOutliersBetaApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * This API exports a list of ignored outliers to a CSV as well as list of non-ignored outliers to a CSV. These two CSVs will be zipped and exported Columns will include: identityID, type, firstDetectionDate, latestDetectionDate, ignored, & attributes (defined set of identity attributes) Requires authorization scope of \'iai:outliers-management:read\'
		         * @summary IAI Identity Outliers Export
		         * @param {'LOW_SIMILARITY' | 'STRUCTURAL'} [type] Type of the identity outliers snapshot to filter on
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        exportOutliersZip: function (type, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/outliers/export";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (type !== undefined) {
		                                localVarQueryParameter['type'] = type;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API receives a summary containing: the number of identities that customer has, the number of outliers, and the type of outlier Requires authorization scope of \'iai:outliers-management:read\'
		         * @summary IAI Identity Outliers Summary
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {'LOW_SIMILARITY' | 'STRUCTURAL'} [type] Type of the identity outliers snapshot to filter on
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **snapshotDate**: *ge, le*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **snapshotDate**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getIdentityOutlierSnapshots: function (limit, offset, type, filters, sorters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/outlier-summaries";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (type !== undefined) {
		                                localVarQueryParameter['type'] = type;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API receives a list of outliers, containing data such as: identityId, outlier type, detection dates, identity attributes, if identity is ignore, and certification information Requires authorization scope of \'iai:outliers-management:read\'
		         * @summary IAI Get Identity Outliers
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {'LOW_SIMILARITY' | 'STRUCTURAL'} [type] Type of the identity outliers snapshot to filter on
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **attributes**: *eq, sw, co, in*  **firstDetectionDate**: *ge, le*  **certStatus**: *eq*  **ignored**: *eq*  **score**: *ge, le*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **firstDetectionDate, attributes, score**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getIdentityOutliers: function (limit, offset, count, type, filters, sorters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/outliers";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (type !== undefined) {
		                                localVarQueryParameter['type'] = type;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns a most recent snapshot of each outlier type, each containing: the number of identities that customer has, the number of outliers, and the type of outlier Requires authorization scope of \'iai:outliers-management:read\'
		         * @summary IAI Identity Outliers Latest Summary
		         * @param {'LOW_SIMILARITY' | 'STRUCTURAL'} [type] Type of the identity outliers snapshot to filter on
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getLatestIdentityOutlierSnapshots: function (type, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/outlier-summaries/latest";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (type !== undefined) {
		                                localVarQueryParameter['type'] = type;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns a summary of a contributing feature for an identity outlier. The object contains: contributing feature name (translated text or message key), identity outlier display name, feature values, feature definition and explanation (translated text or message key), peer display name and identityId, access item reference, translation messages object Requires authorization scope of \'iai:outliers-management:read\'
		         * @summary Get identity outlier contibuting feature summary
		         * @param {string} outlierFeatureId Contributing feature id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getOutlierContributingFeatureSummary: function (outlierFeatureId, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'outlierFeatureId' is not null or undefined
		                            (0, common_1.assertParamExists)('getOutlierContributingFeatureSummary', 'outlierFeatureId', outlierFeatureId);
		                            localVarPath = "/outlier-feature-summaries/{outlierFeatureId}"
		                                .replace("{".concat("outlierFeatureId", "}"), encodeURIComponent(String(outlierFeatureId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns a list of contributing feature objects for a single outlier. The object contains: feature name, feature value type, value, importance, display name (translated text or message key), description (translated text or message key), translation messages object Requires authorization scope of \'iai:outliers-management:read\'
		         * @summary Get identity outlier\'s contibuting features
		         * @param {string} outlierId The outlier id
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [includeTranslationMessages] Whether or not to include translation messages object in returned response
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **importance**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getPeerGroupOutliersContributingFeatures: function (outlierId, limit, offset, count, includeTranslationMessages, sorters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'outlierId' is not null or undefined
		                            (0, common_1.assertParamExists)('getPeerGroupOutliersContributingFeatures', 'outlierId', outlierId);
		                            localVarPath = "/outliers/{outlierId}/contributing-features"
		                                .replace("{".concat("outlierId", "}"), encodeURIComponent(String(outlierId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (includeTranslationMessages !== undefined) {
		                                localVarQueryParameter['include-translation-messages'] = includeTranslationMessages;
		                            }
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API receives a list of IdentityIDs in the request, changes the outliers to be ignored--returning a 204 if successful. Requires authorization scope of \'iai:outliers-management:update\'
		         * @summary IAI Identity Outliers Ignore
		         * @param {Array<string>} requestBody
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        ignoreIdentityOutliers: function (requestBody, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'requestBody' is not null or undefined
		                            (0, common_1.assertParamExists)('ignoreIdentityOutliers', 'requestBody', requestBody);
		                            localVarPath = "/outliers/ignore";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(requestBody, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns a list of the enriched access items associated with each feature filtered by the access item type  The object contains: accessItemId, display name (translated text or message key), description (translated text or message key), accessType, sourceName, extremelyRare Requires authorization scope of \'iai:outliers-management:read\'
		         * @summary Gets a list of access items associated with each identity outlier contributing feature
		         * @param {string} outlierId The outlier id
		         * @param {'radical_entitlement_count' | 'entitlement_count' | 'max_jaccard_similarity' | 'mean_max_bundle_concurrency' | 'single_entitlement_bundle_count' | 'peerless_score'} contributingFeatureName The name of contributing feature
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [accessType] The type of access item for the identity outlier contributing feature. If not provided, it returns all
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **displayName**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listOutliersContributingFeatureAccessItems: function (outlierId, contributingFeatureName, limit, offset, count, accessType, sorters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'outlierId' is not null or undefined
		                            (0, common_1.assertParamExists)('listOutliersContributingFeatureAccessItems', 'outlierId', outlierId);
		                            // verify required parameter 'contributingFeatureName' is not null or undefined
		                            (0, common_1.assertParamExists)('listOutliersContributingFeatureAccessItems', 'contributingFeatureName', contributingFeatureName);
		                            localVarPath = "/outliers/{outlierId}/feature-details/{contributingFeatureName}/access-items"
		                                .replace("{".concat("outlierId", "}"), encodeURIComponent(String(outlierId)))
		                                .replace("{".concat("contributingFeatureName", "}"), encodeURIComponent(String(contributingFeatureName)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (accessType !== undefined) {
		                                localVarQueryParameter['accessType'] = accessType;
		                            }
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API receives a list of IdentityIDs in the request, changes the outliers to be un-ignored--returning a 204 if successful. Requires authorization scope of \'iai:outliers-management:update\'
		         * @summary IAI Identity Outliers Unignore
		         * @param {Array<string>} requestBody
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        unIgnoreIdentityOutliers: function (requestBody, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'requestBody' is not null or undefined
		                            (0, common_1.assertParamExists)('unIgnoreIdentityOutliers', 'requestBody', requestBody);
		                            localVarPath = "/outliers/unignore";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(requestBody, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.IAIOutliersBetaApiAxiosParamCreator = IAIOutliersBetaApiAxiosParamCreator;
		/**
		 * IAIOutliersBetaApi - functional programming interface
		 * @export
		 */
		var IAIOutliersBetaApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.IAIOutliersBetaApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * This API exports a list of ignored outliers to a CSV as well as list of non-ignored outliers to a CSV. These two CSVs will be zipped and exported Columns will include: identityID, type, firstDetectionDate, latestDetectionDate, ignored, & attributes (defined set of identity attributes) Requires authorization scope of \'iai:outliers-management:read\'
		         * @summary IAI Identity Outliers Export
		         * @param {'LOW_SIMILARITY' | 'STRUCTURAL'} [type] Type of the identity outliers snapshot to filter on
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        exportOutliersZip: function (type, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.exportOutliersZip(type, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API receives a summary containing: the number of identities that customer has, the number of outliers, and the type of outlier Requires authorization scope of \'iai:outliers-management:read\'
		         * @summary IAI Identity Outliers Summary
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {'LOW_SIMILARITY' | 'STRUCTURAL'} [type] Type of the identity outliers snapshot to filter on
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **snapshotDate**: *ge, le*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **snapshotDate**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getIdentityOutlierSnapshots: function (limit, offset, type, filters, sorters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getIdentityOutlierSnapshots(limit, offset, type, filters, sorters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API receives a list of outliers, containing data such as: identityId, outlier type, detection dates, identity attributes, if identity is ignore, and certification information Requires authorization scope of \'iai:outliers-management:read\'
		         * @summary IAI Get Identity Outliers
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {'LOW_SIMILARITY' | 'STRUCTURAL'} [type] Type of the identity outliers snapshot to filter on
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **attributes**: *eq, sw, co, in*  **firstDetectionDate**: *ge, le*  **certStatus**: *eq*  **ignored**: *eq*  **score**: *ge, le*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **firstDetectionDate, attributes, score**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getIdentityOutliers: function (limit, offset, count, type, filters, sorters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getIdentityOutliers(limit, offset, count, type, filters, sorters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns a most recent snapshot of each outlier type, each containing: the number of identities that customer has, the number of outliers, and the type of outlier Requires authorization scope of \'iai:outliers-management:read\'
		         * @summary IAI Identity Outliers Latest Summary
		         * @param {'LOW_SIMILARITY' | 'STRUCTURAL'} [type] Type of the identity outliers snapshot to filter on
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getLatestIdentityOutlierSnapshots: function (type, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getLatestIdentityOutlierSnapshots(type, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns a summary of a contributing feature for an identity outlier. The object contains: contributing feature name (translated text or message key), identity outlier display name, feature values, feature definition and explanation (translated text or message key), peer display name and identityId, access item reference, translation messages object Requires authorization scope of \'iai:outliers-management:read\'
		         * @summary Get identity outlier contibuting feature summary
		         * @param {string} outlierFeatureId Contributing feature id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getOutlierContributingFeatureSummary: function (outlierFeatureId, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getOutlierContributingFeatureSummary(outlierFeatureId, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns a list of contributing feature objects for a single outlier. The object contains: feature name, feature value type, value, importance, display name (translated text or message key), description (translated text or message key), translation messages object Requires authorization scope of \'iai:outliers-management:read\'
		         * @summary Get identity outlier\'s contibuting features
		         * @param {string} outlierId The outlier id
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [includeTranslationMessages] Whether or not to include translation messages object in returned response
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **importance**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getPeerGroupOutliersContributingFeatures: function (outlierId, limit, offset, count, includeTranslationMessages, sorters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getPeerGroupOutliersContributingFeatures(outlierId, limit, offset, count, includeTranslationMessages, sorters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API receives a list of IdentityIDs in the request, changes the outliers to be ignored--returning a 204 if successful. Requires authorization scope of \'iai:outliers-management:update\'
		         * @summary IAI Identity Outliers Ignore
		         * @param {Array<string>} requestBody
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        ignoreIdentityOutliers: function (requestBody, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.ignoreIdentityOutliers(requestBody, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns a list of the enriched access items associated with each feature filtered by the access item type  The object contains: accessItemId, display name (translated text or message key), description (translated text or message key), accessType, sourceName, extremelyRare Requires authorization scope of \'iai:outliers-management:read\'
		         * @summary Gets a list of access items associated with each identity outlier contributing feature
		         * @param {string} outlierId The outlier id
		         * @param {'radical_entitlement_count' | 'entitlement_count' | 'max_jaccard_similarity' | 'mean_max_bundle_concurrency' | 'single_entitlement_bundle_count' | 'peerless_score'} contributingFeatureName The name of contributing feature
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [accessType] The type of access item for the identity outlier contributing feature. If not provided, it returns all
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **displayName**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listOutliersContributingFeatureAccessItems: function (outlierId, contributingFeatureName, limit, offset, count, accessType, sorters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listOutliersContributingFeatureAccessItems(outlierId, contributingFeatureName, limit, offset, count, accessType, sorters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API receives a list of IdentityIDs in the request, changes the outliers to be un-ignored--returning a 204 if successful. Requires authorization scope of \'iai:outliers-management:update\'
		         * @summary IAI Identity Outliers Unignore
		         * @param {Array<string>} requestBody
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        unIgnoreIdentityOutliers: function (requestBody, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.unIgnoreIdentityOutliers(requestBody, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.IAIOutliersBetaApiFp = IAIOutliersBetaApiFp;
		/**
		 * IAIOutliersBetaApi - factory interface
		 * @export
		 */
		var IAIOutliersBetaApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.IAIOutliersBetaApiFp)(configuration);
		    return {
		        /**
		         * This API exports a list of ignored outliers to a CSV as well as list of non-ignored outliers to a CSV. These two CSVs will be zipped and exported Columns will include: identityID, type, firstDetectionDate, latestDetectionDate, ignored, & attributes (defined set of identity attributes) Requires authorization scope of \'iai:outliers-management:read\'
		         * @summary IAI Identity Outliers Export
		         * @param {'LOW_SIMILARITY' | 'STRUCTURAL'} [type] Type of the identity outliers snapshot to filter on
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        exportOutliersZip: function (type, axiosOptions) {
		            return localVarFp.exportOutliersZip(type, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API receives a summary containing: the number of identities that customer has, the number of outliers, and the type of outlier Requires authorization scope of \'iai:outliers-management:read\'
		         * @summary IAI Identity Outliers Summary
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {'LOW_SIMILARITY' | 'STRUCTURAL'} [type] Type of the identity outliers snapshot to filter on
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **snapshotDate**: *ge, le*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **snapshotDate**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getIdentityOutlierSnapshots: function (limit, offset, type, filters, sorters, axiosOptions) {
		            return localVarFp.getIdentityOutlierSnapshots(limit, offset, type, filters, sorters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API receives a list of outliers, containing data such as: identityId, outlier type, detection dates, identity attributes, if identity is ignore, and certification information Requires authorization scope of \'iai:outliers-management:read\'
		         * @summary IAI Get Identity Outliers
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {'LOW_SIMILARITY' | 'STRUCTURAL'} [type] Type of the identity outliers snapshot to filter on
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **attributes**: *eq, sw, co, in*  **firstDetectionDate**: *ge, le*  **certStatus**: *eq*  **ignored**: *eq*  **score**: *ge, le*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **firstDetectionDate, attributes, score**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getIdentityOutliers: function (limit, offset, count, type, filters, sorters, axiosOptions) {
		            return localVarFp.getIdentityOutliers(limit, offset, count, type, filters, sorters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API returns a most recent snapshot of each outlier type, each containing: the number of identities that customer has, the number of outliers, and the type of outlier Requires authorization scope of \'iai:outliers-management:read\'
		         * @summary IAI Identity Outliers Latest Summary
		         * @param {'LOW_SIMILARITY' | 'STRUCTURAL'} [type] Type of the identity outliers snapshot to filter on
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getLatestIdentityOutlierSnapshots: function (type, axiosOptions) {
		            return localVarFp.getLatestIdentityOutlierSnapshots(type, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API returns a summary of a contributing feature for an identity outlier. The object contains: contributing feature name (translated text or message key), identity outlier display name, feature values, feature definition and explanation (translated text or message key), peer display name and identityId, access item reference, translation messages object Requires authorization scope of \'iai:outliers-management:read\'
		         * @summary Get identity outlier contibuting feature summary
		         * @param {string} outlierFeatureId Contributing feature id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getOutlierContributingFeatureSummary: function (outlierFeatureId, axiosOptions) {
		            return localVarFp.getOutlierContributingFeatureSummary(outlierFeatureId, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API returns a list of contributing feature objects for a single outlier. The object contains: feature name, feature value type, value, importance, display name (translated text or message key), description (translated text or message key), translation messages object Requires authorization scope of \'iai:outliers-management:read\'
		         * @summary Get identity outlier\'s contibuting features
		         * @param {string} outlierId The outlier id
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [includeTranslationMessages] Whether or not to include translation messages object in returned response
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **importance**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getPeerGroupOutliersContributingFeatures: function (outlierId, limit, offset, count, includeTranslationMessages, sorters, axiosOptions) {
		            return localVarFp.getPeerGroupOutliersContributingFeatures(outlierId, limit, offset, count, includeTranslationMessages, sorters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API receives a list of IdentityIDs in the request, changes the outliers to be ignored--returning a 204 if successful. Requires authorization scope of \'iai:outliers-management:update\'
		         * @summary IAI Identity Outliers Ignore
		         * @param {Array<string>} requestBody
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        ignoreIdentityOutliers: function (requestBody, axiosOptions) {
		            return localVarFp.ignoreIdentityOutliers(requestBody, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API returns a list of the enriched access items associated with each feature filtered by the access item type  The object contains: accessItemId, display name (translated text or message key), description (translated text or message key), accessType, sourceName, extremelyRare Requires authorization scope of \'iai:outliers-management:read\'
		         * @summary Gets a list of access items associated with each identity outlier contributing feature
		         * @param {string} outlierId The outlier id
		         * @param {'radical_entitlement_count' | 'entitlement_count' | 'max_jaccard_similarity' | 'mean_max_bundle_concurrency' | 'single_entitlement_bundle_count' | 'peerless_score'} contributingFeatureName The name of contributing feature
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [accessType] The type of access item for the identity outlier contributing feature. If not provided, it returns all
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **displayName**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listOutliersContributingFeatureAccessItems: function (outlierId, contributingFeatureName, limit, offset, count, accessType, sorters, axiosOptions) {
		            return localVarFp.listOutliersContributingFeatureAccessItems(outlierId, contributingFeatureName, limit, offset, count, accessType, sorters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API receives a list of IdentityIDs in the request, changes the outliers to be un-ignored--returning a 204 if successful. Requires authorization scope of \'iai:outliers-management:update\'
		         * @summary IAI Identity Outliers Unignore
		         * @param {Array<string>} requestBody
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        unIgnoreIdentityOutliers: function (requestBody, axiosOptions) {
		            return localVarFp.unIgnoreIdentityOutliers(requestBody, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.IAIOutliersBetaApiFactory = IAIOutliersBetaApiFactory;
		/**
		 * IAIOutliersBetaApi - object-oriented interface
		 * @export
		 * @class IAIOutliersBetaApi
		 * @extends {BaseAPI}
		 */
		var IAIOutliersBetaApi = /** @class */ (function (_super) {
		    __extends(IAIOutliersBetaApi, _super);
		    function IAIOutliersBetaApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * This API exports a list of ignored outliers to a CSV as well as list of non-ignored outliers to a CSV. These two CSVs will be zipped and exported Columns will include: identityID, type, firstDetectionDate, latestDetectionDate, ignored, & attributes (defined set of identity attributes) Requires authorization scope of \'iai:outliers-management:read\'
		     * @summary IAI Identity Outliers Export
		     * @param {IAIOutliersBetaApiExportOutliersZipRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IAIOutliersBetaApi
		     */
		    IAIOutliersBetaApi.prototype.exportOutliersZip = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.IAIOutliersBetaApiFp)(this.configuration).exportOutliersZip(requestParameters.type, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API receives a summary containing: the number of identities that customer has, the number of outliers, and the type of outlier Requires authorization scope of \'iai:outliers-management:read\'
		     * @summary IAI Identity Outliers Summary
		     * @param {IAIOutliersBetaApiGetIdentityOutlierSnapshotsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IAIOutliersBetaApi
		     */
		    IAIOutliersBetaApi.prototype.getIdentityOutlierSnapshots = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.IAIOutliersBetaApiFp)(this.configuration).getIdentityOutlierSnapshots(requestParameters.limit, requestParameters.offset, requestParameters.type, requestParameters.filters, requestParameters.sorters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API receives a list of outliers, containing data such as: identityId, outlier type, detection dates, identity attributes, if identity is ignore, and certification information Requires authorization scope of \'iai:outliers-management:read\'
		     * @summary IAI Get Identity Outliers
		     * @param {IAIOutliersBetaApiGetIdentityOutliersRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IAIOutliersBetaApi
		     */
		    IAIOutliersBetaApi.prototype.getIdentityOutliers = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.IAIOutliersBetaApiFp)(this.configuration).getIdentityOutliers(requestParameters.limit, requestParameters.offset, requestParameters.count, requestParameters.type, requestParameters.filters, requestParameters.sorters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API returns a most recent snapshot of each outlier type, each containing: the number of identities that customer has, the number of outliers, and the type of outlier Requires authorization scope of \'iai:outliers-management:read\'
		     * @summary IAI Identity Outliers Latest Summary
		     * @param {IAIOutliersBetaApiGetLatestIdentityOutlierSnapshotsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IAIOutliersBetaApi
		     */
		    IAIOutliersBetaApi.prototype.getLatestIdentityOutlierSnapshots = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.IAIOutliersBetaApiFp)(this.configuration).getLatestIdentityOutlierSnapshots(requestParameters.type, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API returns a summary of a contributing feature for an identity outlier. The object contains: contributing feature name (translated text or message key), identity outlier display name, feature values, feature definition and explanation (translated text or message key), peer display name and identityId, access item reference, translation messages object Requires authorization scope of \'iai:outliers-management:read\'
		     * @summary Get identity outlier contibuting feature summary
		     * @param {IAIOutliersBetaApiGetOutlierContributingFeatureSummaryRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IAIOutliersBetaApi
		     */
		    IAIOutliersBetaApi.prototype.getOutlierContributingFeatureSummary = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.IAIOutliersBetaApiFp)(this.configuration).getOutlierContributingFeatureSummary(requestParameters.outlierFeatureId, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API returns a list of contributing feature objects for a single outlier. The object contains: feature name, feature value type, value, importance, display name (translated text or message key), description (translated text or message key), translation messages object Requires authorization scope of \'iai:outliers-management:read\'
		     * @summary Get identity outlier\'s contibuting features
		     * @param {IAIOutliersBetaApiGetPeerGroupOutliersContributingFeaturesRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IAIOutliersBetaApi
		     */
		    IAIOutliersBetaApi.prototype.getPeerGroupOutliersContributingFeatures = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.IAIOutliersBetaApiFp)(this.configuration).getPeerGroupOutliersContributingFeatures(requestParameters.outlierId, requestParameters.limit, requestParameters.offset, requestParameters.count, requestParameters.includeTranslationMessages, requestParameters.sorters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API receives a list of IdentityIDs in the request, changes the outliers to be ignored--returning a 204 if successful. Requires authorization scope of \'iai:outliers-management:update\'
		     * @summary IAI Identity Outliers Ignore
		     * @param {IAIOutliersBetaApiIgnoreIdentityOutliersRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IAIOutliersBetaApi
		     */
		    IAIOutliersBetaApi.prototype.ignoreIdentityOutliers = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.IAIOutliersBetaApiFp)(this.configuration).ignoreIdentityOutliers(requestParameters.requestBody, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API returns a list of the enriched access items associated with each feature filtered by the access item type  The object contains: accessItemId, display name (translated text or message key), description (translated text or message key), accessType, sourceName, extremelyRare Requires authorization scope of \'iai:outliers-management:read\'
		     * @summary Gets a list of access items associated with each identity outlier contributing feature
		     * @param {IAIOutliersBetaApiListOutliersContributingFeatureAccessItemsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IAIOutliersBetaApi
		     */
		    IAIOutliersBetaApi.prototype.listOutliersContributingFeatureAccessItems = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.IAIOutliersBetaApiFp)(this.configuration).listOutliersContributingFeatureAccessItems(requestParameters.outlierId, requestParameters.contributingFeatureName, requestParameters.limit, requestParameters.offset, requestParameters.count, requestParameters.accessType, requestParameters.sorters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API receives a list of IdentityIDs in the request, changes the outliers to be un-ignored--returning a 204 if successful. Requires authorization scope of \'iai:outliers-management:update\'
		     * @summary IAI Identity Outliers Unignore
		     * @param {IAIOutliersBetaApiUnIgnoreIdentityOutliersRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IAIOutliersBetaApi
		     */
		    IAIOutliersBetaApi.prototype.unIgnoreIdentityOutliers = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.IAIOutliersBetaApiFp)(this.configuration).unIgnoreIdentityOutliers(requestParameters.requestBody, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return IAIOutliersBetaApi;
		}(base_1.BaseAPI));
		exports.IAIOutliersBetaApi = IAIOutliersBetaApi;
		/**
		 * IAIPeerGroupStrategiesBetaApi - axios parameter creator
		 * @export
		 */
		var IAIPeerGroupStrategiesBetaApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * -- Deprecated : See \'IAI Outliers\' This API will be used by Identity Governance systems to identify identities that are not included in an organization\'s peer groups. By default, 250 identities are returned. You can specify between 1 and 1000 number of identities that can be returned.
		         * @summary Identity Outliers List
		         * @param {string} strategy The strategy used to create peer groups. Currently, \&#39;entitlement\&#39; is supported.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        getPeerGroupOutliers: function (strategy, limit, offset, count, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'strategy' is not null or undefined
		                            (0, common_1.assertParamExists)('getPeerGroupOutliers', 'strategy', strategy);
		                            localVarPath = "/peer-group-strategies/{strategy}/identity-outliers"
		                                .replace("{".concat("strategy", "}"), encodeURIComponent(String(strategy)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.IAIPeerGroupStrategiesBetaApiAxiosParamCreator = IAIPeerGroupStrategiesBetaApiAxiosParamCreator;
		/**
		 * IAIPeerGroupStrategiesBetaApi - functional programming interface
		 * @export
		 */
		var IAIPeerGroupStrategiesBetaApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.IAIPeerGroupStrategiesBetaApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * -- Deprecated : See \'IAI Outliers\' This API will be used by Identity Governance systems to identify identities that are not included in an organization\'s peer groups. By default, 250 identities are returned. You can specify between 1 and 1000 number of identities that can be returned.
		         * @summary Identity Outliers List
		         * @param {string} strategy The strategy used to create peer groups. Currently, \&#39;entitlement\&#39; is supported.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        getPeerGroupOutliers: function (strategy, limit, offset, count, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getPeerGroupOutliers(strategy, limit, offset, count, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.IAIPeerGroupStrategiesBetaApiFp = IAIPeerGroupStrategiesBetaApiFp;
		/**
		 * IAIPeerGroupStrategiesBetaApi - factory interface
		 * @export
		 */
		var IAIPeerGroupStrategiesBetaApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.IAIPeerGroupStrategiesBetaApiFp)(configuration);
		    return {
		        /**
		         * -- Deprecated : See \'IAI Outliers\' This API will be used by Identity Governance systems to identify identities that are not included in an organization\'s peer groups. By default, 250 identities are returned. You can specify between 1 and 1000 number of identities that can be returned.
		         * @summary Identity Outliers List
		         * @param {string} strategy The strategy used to create peer groups. Currently, \&#39;entitlement\&#39; is supported.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        getPeerGroupOutliers: function (strategy, limit, offset, count, axiosOptions) {
		            return localVarFp.getPeerGroupOutliers(strategy, limit, offset, count, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.IAIPeerGroupStrategiesBetaApiFactory = IAIPeerGroupStrategiesBetaApiFactory;
		/**
		 * IAIPeerGroupStrategiesBetaApi - object-oriented interface
		 * @export
		 * @class IAIPeerGroupStrategiesBetaApi
		 * @extends {BaseAPI}
		 */
		var IAIPeerGroupStrategiesBetaApi = /** @class */ (function (_super) {
		    __extends(IAIPeerGroupStrategiesBetaApi, _super);
		    function IAIPeerGroupStrategiesBetaApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * -- Deprecated : See \'IAI Outliers\' This API will be used by Identity Governance systems to identify identities that are not included in an organization\'s peer groups. By default, 250 identities are returned. You can specify between 1 and 1000 number of identities that can be returned.
		     * @summary Identity Outliers List
		     * @param {IAIPeerGroupStrategiesBetaApiGetPeerGroupOutliersRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @deprecated
		     * @throws {RequiredError}
		     * @memberof IAIPeerGroupStrategiesBetaApi
		     */
		    IAIPeerGroupStrategiesBetaApi.prototype.getPeerGroupOutliers = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.IAIPeerGroupStrategiesBetaApiFp)(this.configuration).getPeerGroupOutliers(requestParameters.strategy, requestParameters.limit, requestParameters.offset, requestParameters.count, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return IAIPeerGroupStrategiesBetaApi;
		}(base_1.BaseAPI));
		exports.IAIPeerGroupStrategiesBetaApi = IAIPeerGroupStrategiesBetaApi;
		/**
		 * IAIRecommendationsBetaApi - axios parameter creator
		 * @export
		 */
		var IAIRecommendationsBetaApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * The getRecommendations API returns recommendations based on the requested object. The recommendations are invoked by IdentityIQ and IdentityNow plug-ins that retrieve recommendations based on the performed calculations.
		         * @summary Returns a Recommendation Based on Object
		         * @param {RecommendationRequestDtoBeta} recommendationRequestDtoBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getRecommendations: function (recommendationRequestDtoBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'recommendationRequestDtoBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('getRecommendations', 'recommendationRequestDtoBeta', recommendationRequestDtoBeta);
		                            localVarPath = "/recommendations/request";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(recommendationRequestDtoBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Retrieves configuration attributes used by certification recommendations.
		         * @summary Get certification recommendation config values
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getRecommendationsConfig: function (axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/recommendations/config";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Updates configuration attributes used by certification recommendations.
		         * @summary Update certification recommendation config values
		         * @param {RecommendationConfigDtoBeta} recommendationConfigDtoBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateRecommendationsConfig: function (recommendationConfigDtoBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'recommendationConfigDtoBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('updateRecommendationsConfig', 'recommendationConfigDtoBeta', recommendationConfigDtoBeta);
		                            localVarPath = "/recommendations/config";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PUT' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(recommendationConfigDtoBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.IAIRecommendationsBetaApiAxiosParamCreator = IAIRecommendationsBetaApiAxiosParamCreator;
		/**
		 * IAIRecommendationsBetaApi - functional programming interface
		 * @export
		 */
		var IAIRecommendationsBetaApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.IAIRecommendationsBetaApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * The getRecommendations API returns recommendations based on the requested object. The recommendations are invoked by IdentityIQ and IdentityNow plug-ins that retrieve recommendations based on the performed calculations.
		         * @summary Returns a Recommendation Based on Object
		         * @param {RecommendationRequestDtoBeta} recommendationRequestDtoBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getRecommendations: function (recommendationRequestDtoBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getRecommendations(recommendationRequestDtoBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Retrieves configuration attributes used by certification recommendations.
		         * @summary Get certification recommendation config values
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getRecommendationsConfig: function (axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getRecommendationsConfig(axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Updates configuration attributes used by certification recommendations.
		         * @summary Update certification recommendation config values
		         * @param {RecommendationConfigDtoBeta} recommendationConfigDtoBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateRecommendationsConfig: function (recommendationConfigDtoBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.updateRecommendationsConfig(recommendationConfigDtoBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.IAIRecommendationsBetaApiFp = IAIRecommendationsBetaApiFp;
		/**
		 * IAIRecommendationsBetaApi - factory interface
		 * @export
		 */
		var IAIRecommendationsBetaApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.IAIRecommendationsBetaApiFp)(configuration);
		    return {
		        /**
		         * The getRecommendations API returns recommendations based on the requested object. The recommendations are invoked by IdentityIQ and IdentityNow plug-ins that retrieve recommendations based on the performed calculations.
		         * @summary Returns a Recommendation Based on Object
		         * @param {RecommendationRequestDtoBeta} recommendationRequestDtoBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getRecommendations: function (recommendationRequestDtoBeta, axiosOptions) {
		            return localVarFp.getRecommendations(recommendationRequestDtoBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Retrieves configuration attributes used by certification recommendations.
		         * @summary Get certification recommendation config values
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getRecommendationsConfig: function (axiosOptions) {
		            return localVarFp.getRecommendationsConfig(axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Updates configuration attributes used by certification recommendations.
		         * @summary Update certification recommendation config values
		         * @param {RecommendationConfigDtoBeta} recommendationConfigDtoBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateRecommendationsConfig: function (recommendationConfigDtoBeta, axiosOptions) {
		            return localVarFp.updateRecommendationsConfig(recommendationConfigDtoBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.IAIRecommendationsBetaApiFactory = IAIRecommendationsBetaApiFactory;
		/**
		 * IAIRecommendationsBetaApi - object-oriented interface
		 * @export
		 * @class IAIRecommendationsBetaApi
		 * @extends {BaseAPI}
		 */
		var IAIRecommendationsBetaApi = /** @class */ (function (_super) {
		    __extends(IAIRecommendationsBetaApi, _super);
		    function IAIRecommendationsBetaApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * The getRecommendations API returns recommendations based on the requested object. The recommendations are invoked by IdentityIQ and IdentityNow plug-ins that retrieve recommendations based on the performed calculations.
		     * @summary Returns a Recommendation Based on Object
		     * @param {IAIRecommendationsBetaApiGetRecommendationsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IAIRecommendationsBetaApi
		     */
		    IAIRecommendationsBetaApi.prototype.getRecommendations = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.IAIRecommendationsBetaApiFp)(this.configuration).getRecommendations(requestParameters.recommendationRequestDtoBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Retrieves configuration attributes used by certification recommendations.
		     * @summary Get certification recommendation config values
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IAIRecommendationsBetaApi
		     */
		    IAIRecommendationsBetaApi.prototype.getRecommendationsConfig = function (axiosOptions) {
		        var _this = this;
		        return (0, exports.IAIRecommendationsBetaApiFp)(this.configuration).getRecommendationsConfig(axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Updates configuration attributes used by certification recommendations.
		     * @summary Update certification recommendation config values
		     * @param {IAIRecommendationsBetaApiUpdateRecommendationsConfigRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IAIRecommendationsBetaApi
		     */
		    IAIRecommendationsBetaApi.prototype.updateRecommendationsConfig = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.IAIRecommendationsBetaApiFp)(this.configuration).updateRecommendationsConfig(requestParameters.recommendationConfigDtoBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return IAIRecommendationsBetaApi;
		}(base_1.BaseAPI));
		exports.IAIRecommendationsBetaApi = IAIRecommendationsBetaApi;
		/**
		 * IAIRoleMiningBetaApi - axios parameter creator
		 * @export
		 */
		var IAIRoleMiningBetaApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * This method starts a job to provision a potential role
		         * @summary Create request to provision a potential role into an actual role.
		         * @param {string} sessionId The role mining session id
		         * @param {string} potentialRoleId A potential role id in a role mining session
		         * @param {number} [minEntitlementPopularity] Minimum popularity required for an entitlement to be included in the provisioned role.
		         * @param {boolean} [includeCommonAccess] Boolean determining whether common access entitlements will be included in the provisioned role.
		         * @param {RoleMiningPotentialRoleProvisionRequestBeta} [roleMiningPotentialRoleProvisionRequestBeta] Required information to create a new role
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createPotentialRoleProvisionRequest: function (sessionId, potentialRoleId, minEntitlementPopularity, includeCommonAccess, roleMiningPotentialRoleProvisionRequestBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'sessionId' is not null or undefined
		                            (0, common_1.assertParamExists)('createPotentialRoleProvisionRequest', 'sessionId', sessionId);
		                            // verify required parameter 'potentialRoleId' is not null or undefined
		                            (0, common_1.assertParamExists)('createPotentialRoleProvisionRequest', 'potentialRoleId', potentialRoleId);
		                            localVarPath = "/role-mining-sessions/{sessionId}/potential-roles/{potentialRoleId}/provision"
		                                .replace("{".concat("sessionId", "}"), encodeURIComponent(String(sessionId)))
		                                .replace("{".concat("potentialRoleId", "}"), encodeURIComponent(String(potentialRoleId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (minEntitlementPopularity !== undefined) {
		                                localVarQueryParameter['min-entitlement-popularity'] = minEntitlementPopularity;
		                            }
		                            if (includeCommonAccess !== undefined) {
		                                localVarQueryParameter['include-common-access'] = includeCommonAccess;
		                            }
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(roleMiningPotentialRoleProvisionRequestBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This submits a create role mining session request to the role mining application.
		         * @summary Create a role mining session
		         * @param {RoleMiningSessionDtoBeta} roleMiningSessionDtoBeta Role mining session parameters
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createRoleMiningSessions: function (roleMiningSessionDtoBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'roleMiningSessionDtoBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('createRoleMiningSessions', 'roleMiningSessionDtoBeta', roleMiningSessionDtoBeta);
		                            localVarPath = "/role-mining-sessions";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(roleMiningSessionDtoBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This endpoint downloads a completed export of information for a potential role in a role mining session.
		         * @summary Export (download) details for a potential role in a role mining session
		         * @param {string} sessionId The role mining session id
		         * @param {string} potentialRoleId A potential role id in a role mining session
		         * @param {string} exportId The id of a previously run export job for this potential role
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        downloadRoleMiningPotentialRoleZip: function (sessionId, potentialRoleId, exportId, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'sessionId' is not null or undefined
		                            (0, common_1.assertParamExists)('downloadRoleMiningPotentialRoleZip', 'sessionId', sessionId);
		                            // verify required parameter 'potentialRoleId' is not null or undefined
		                            (0, common_1.assertParamExists)('downloadRoleMiningPotentialRoleZip', 'potentialRoleId', potentialRoleId);
		                            // verify required parameter 'exportId' is not null or undefined
		                            (0, common_1.assertParamExists)('downloadRoleMiningPotentialRoleZip', 'exportId', exportId);
		                            localVarPath = "/role-mining-sessions/{sessionId}/potential-roles/{potentialRoleId}/export-async/{exportId}/download"
		                                .replace("{".concat("sessionId", "}"), encodeURIComponent(String(sessionId)))
		                                .replace("{".concat("potentialRoleId", "}"), encodeURIComponent(String(potentialRoleId)))
		                                .replace("{".concat("exportId", "}"), encodeURIComponent(String(exportId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This endpoint downloads all the information for a potential role in a role mining session. Includes identities and entitlements in the potential role.
		         * @summary Export (download) details for a potential role in a role mining session
		         * @param {string} sessionId The role mining session id
		         * @param {string} potentialRoleId A potential role id in a role mining session
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        exportRoleMiningPotentialRole: function (sessionId, potentialRoleId, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'sessionId' is not null or undefined
		                            (0, common_1.assertParamExists)('exportRoleMiningPotentialRole', 'sessionId', sessionId);
		                            // verify required parameter 'potentialRoleId' is not null or undefined
		                            (0, common_1.assertParamExists)('exportRoleMiningPotentialRole', 'potentialRoleId', potentialRoleId);
		                            localVarPath = "/role-mining-sessions/{sessionId}/potential-roles/{potentialRoleId}/export"
		                                .replace("{".concat("sessionId", "}"), encodeURIComponent(String(sessionId)))
		                                .replace("{".concat("potentialRoleId", "}"), encodeURIComponent(String(potentialRoleId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This endpoint uploads all the information for a potential role in a role mining session to S3 as a downloadable zip archive.  Includes identities and entitlements in the potential role.
		         * @summary Asynchronously export details for a potential role in a role mining session and upload to S3
		         * @param {string} sessionId The role mining session id
		         * @param {string} potentialRoleId A potential role id in a role mining session
		         * @param {RoleMiningPotentialRoleExportRequestBeta} [roleMiningPotentialRoleExportRequestBeta]
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        exportRoleMiningPotentialRoleAsync: function (sessionId, potentialRoleId, roleMiningPotentialRoleExportRequestBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'sessionId' is not null or undefined
		                            (0, common_1.assertParamExists)('exportRoleMiningPotentialRoleAsync', 'sessionId', sessionId);
		                            // verify required parameter 'potentialRoleId' is not null or undefined
		                            (0, common_1.assertParamExists)('exportRoleMiningPotentialRoleAsync', 'potentialRoleId', potentialRoleId);
		                            localVarPath = "/role-mining-sessions/{sessionId}/potential-roles/{potentialRoleId}/export-async"
		                                .replace("{".concat("sessionId", "}"), encodeURIComponent(String(sessionId)))
		                                .replace("{".concat("potentialRoleId", "}"), encodeURIComponent(String(potentialRoleId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(roleMiningPotentialRoleExportRequestBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This endpoint retrieves information about the current status of a potential role export.
		         * @summary Retrieve status of a potential role export job
		         * @param {string} sessionId The role mining session id
		         * @param {string} potentialRoleId A potential role id in a role mining session
		         * @param {string} exportId The id of a previously run export job for this potential role
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        exportRoleMiningPotentialRoleStatus: function (sessionId, potentialRoleId, exportId, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'sessionId' is not null or undefined
		                            (0, common_1.assertParamExists)('exportRoleMiningPotentialRoleStatus', 'sessionId', sessionId);
		                            // verify required parameter 'potentialRoleId' is not null or undefined
		                            (0, common_1.assertParamExists)('exportRoleMiningPotentialRoleStatus', 'potentialRoleId', potentialRoleId);
		                            // verify required parameter 'exportId' is not null or undefined
		                            (0, common_1.assertParamExists)('exportRoleMiningPotentialRoleStatus', 'exportId', exportId);
		                            localVarPath = "/role-mining-sessions/{sessionId}/potential-roles/{potentialRoleId}/export-async/{exportId}"
		                                .replace("{".concat("sessionId", "}"), encodeURIComponent(String(sessionId)))
		                                .replace("{".concat("potentialRoleId", "}"), encodeURIComponent(String(potentialRoleId)))
		                                .replace("{".concat("exportId", "}"), encodeURIComponent(String(exportId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Returns all potential role summaries that match the query parameters
		         * @summary Retrieves all potential role summaries
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **createdDate, identityCount, entitlementCount, freshness, quality**
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **createdById**: *eq, sw, co*  **createdByName**: *eq, sw, co*  **description**: *sw, co*  **endDate**: *le, lt*  **freshness**: *eq, ge, gt, le, lt*  **name**: *eq, sw, co, ge, gt, le, lt*  **quality**: *eq, ge, gt, le, lt*  **startDate**: *ge, gt*  **saved**: *eq*  **type**: *eq, ge, gt, le, lt*  **scopingMethod**: *eq*  **sessionState**: *eq*  **identityAttribute**: *co*
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getAllPotentialRoleSummaries: function (sorters, filters, offset, limit, count, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/role-mining-potential-roles";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This method returns entitlement popularity distribution for a potential role in a role mining session.
		         * @summary Retrieves entitlement popularity distribution for a potential role in a role mining session
		         * @param {string} sessionId The role mining session id
		         * @param {string} potentialRoleId A potential role id in a role mining session
		         * @param {boolean} [includeCommonAccess] Boolean determining whether common access entitlements will be included or not
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getEntitlementDistributionPotentialRole: function (sessionId, potentialRoleId, includeCommonAccess, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'sessionId' is not null or undefined
		                            (0, common_1.assertParamExists)('getEntitlementDistributionPotentialRole', 'sessionId', sessionId);
		                            // verify required parameter 'potentialRoleId' is not null or undefined
		                            (0, common_1.assertParamExists)('getEntitlementDistributionPotentialRole', 'potentialRoleId', potentialRoleId);
		                            localVarPath = "/role-mining-sessions/{sessionId}/potential-roles/{potentialRoleId}/entitlement-popularity-distribution"
		                                .replace("{".concat("sessionId", "}"), encodeURIComponent(String(sessionId)))
		                                .replace("{".concat("potentialRoleId", "}"), encodeURIComponent(String(potentialRoleId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (includeCommonAccess !== undefined) {
		                                localVarQueryParameter['includeCommonAccess'] = includeCommonAccess;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This method returns entitlements for a potential role in a role mining session.
		         * @summary Retrieves entitlements for a potential role in a role mining session
		         * @param {string} sessionId The role mining session id
		         * @param {string} potentialRoleId A potential role id in a role mining session
		         * @param {boolean} [includeCommonAccess] Boolean determining whether common access entitlements will be included or not
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **popularity**  The default sort is **popularity** in descending order.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **applicationName**: *sw*  **entitlementRef.name**: *sw*
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getEntitlementsPotentialRole: function (sessionId, potentialRoleId, includeCommonAccess, sorters, filters, offset, limit, count, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'sessionId' is not null or undefined
		                            (0, common_1.assertParamExists)('getEntitlementsPotentialRole', 'sessionId', sessionId);
		                            // verify required parameter 'potentialRoleId' is not null or undefined
		                            (0, common_1.assertParamExists)('getEntitlementsPotentialRole', 'potentialRoleId', potentialRoleId);
		                            localVarPath = "/role-mining-sessions/{sessionId}/potential-roles/{potentialRoleId}/entitlement-popularities"
		                                .replace("{".concat("sessionId", "}"), encodeURIComponent(String(sessionId)))
		                                .replace("{".concat("potentialRoleId", "}"), encodeURIComponent(String(potentialRoleId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (includeCommonAccess !== undefined) {
		                                localVarQueryParameter['includeCommonAccess'] = includeCommonAccess;
		                            }
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This method returns excluded entitlements for a potential role in a role mining session.
		         * @summary Retrieves excluded entitlements for a potential role in a role mining session
		         * @param {string} sessionId The role mining session id
		         * @param {string} potentialRoleId A potential role id in a role mining session
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **popularity**
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **applicationName**: *sw*  **entitlementRef.name**: *sw*
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getExcludedEntitlementsPotentialRole: function (sessionId, potentialRoleId, sorters, filters, offset, limit, count, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'sessionId' is not null or undefined
		                            (0, common_1.assertParamExists)('getExcludedEntitlementsPotentialRole', 'sessionId', sessionId);
		                            // verify required parameter 'potentialRoleId' is not null or undefined
		                            (0, common_1.assertParamExists)('getExcludedEntitlementsPotentialRole', 'potentialRoleId', potentialRoleId);
		                            localVarPath = "/role-mining-sessions/{sessionId}/potential-roles/{potentialRoleId}/excluded-entitlements"
		                                .replace("{".concat("sessionId", "}"), encodeURIComponent(String(sessionId)))
		                                .replace("{".concat("potentialRoleId", "}"), encodeURIComponent(String(potentialRoleId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This method returns identities for a potential role in a role mining session.
		         * @summary Retrieves identities for a potential role in a role mining session
		         * @param {string} sessionId The role mining session id
		         * @param {string} potentialRoleId A potential role id in a role mining session
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name**
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **name**: *sw*
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getIdentitiesPotentialRole: function (sessionId, potentialRoleId, sorters, filters, offset, limit, count, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'sessionId' is not null or undefined
		                            (0, common_1.assertParamExists)('getIdentitiesPotentialRole', 'sessionId', sessionId);
		                            // verify required parameter 'potentialRoleId' is not null or undefined
		                            (0, common_1.assertParamExists)('getIdentitiesPotentialRole', 'potentialRoleId', potentialRoleId);
		                            localVarPath = "/role-mining-sessions/{sessionId}/potential-roles/{potentialRoleId}/identities"
		                                .replace("{".concat("sessionId", "}"), encodeURIComponent(String(sessionId)))
		                                .replace("{".concat("potentialRoleId", "}"), encodeURIComponent(String(potentialRoleId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This method returns a specific potential role for a role mining session.
		         * @summary Retrieves a specific potential role
		         * @param {string} sessionId The role mining session id
		         * @param {string} potentialRoleId A potential role id in a role mining session
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getPotentialRole: function (sessionId, potentialRoleId, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'sessionId' is not null or undefined
		                            (0, common_1.assertParamExists)('getPotentialRole', 'sessionId', sessionId);
		                            // verify required parameter 'potentialRoleId' is not null or undefined
		                            (0, common_1.assertParamExists)('getPotentialRole', 'potentialRoleId', potentialRoleId);
		                            localVarPath = "/role-mining-sessions/{sessionId}/potential-role-summaries/{potentialRoleId}"
		                                .replace("{".concat("sessionId", "}"), encodeURIComponent(String(sessionId)))
		                                .replace("{".concat("potentialRoleId", "}"), encodeURIComponent(String(potentialRoleId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This method returns the applications of a potential role for a role mining session.
		         * @summary Retrieves the applications of a potential role for a role mining session
		         * @param {string} sessionId The role mining session id
		         * @param {string} potentialRoleId A potential role id in a role mining session
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getPotentialRoleApplications: function (sessionId, potentialRoleId, offset, limit, count, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'sessionId' is not null or undefined
		                            (0, common_1.assertParamExists)('getPotentialRoleApplications', 'sessionId', sessionId);
		                            // verify required parameter 'potentialRoleId' is not null or undefined
		                            (0, common_1.assertParamExists)('getPotentialRoleApplications', 'potentialRoleId', potentialRoleId);
		                            localVarPath = "/role-mining-sessions/{sessionId}/potential-role-summaries/{potentialRoleId}/applications"
		                                .replace("{".concat("sessionId", "}"), encodeURIComponent(String(sessionId)))
		                                .replace("{".concat("potentialRoleId", "}"), encodeURIComponent(String(potentialRoleId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This method returns source usageCount (as number of days in the last 90 days) for each identity in a potential role.
		         * @summary Retrieves potential role source usage
		         * @param {string} potentialRoleId A potential role id
		         * @param {string} sourceId A source id
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters/) Sorting is supported for the following fields: **displayName, email, usageCount**
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getPotentialRoleSourceIdentityUsage: function (potentialRoleId, sourceId, sorters, offset, limit, count, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'potentialRoleId' is not null or undefined
		                            (0, common_1.assertParamExists)('getPotentialRoleSourceIdentityUsage', 'potentialRoleId', potentialRoleId);
		                            // verify required parameter 'sourceId' is not null or undefined
		                            (0, common_1.assertParamExists)('getPotentialRoleSourceIdentityUsage', 'sourceId', sourceId);
		                            localVarPath = "/role-mining-potential-roles/{potentialRoleId}/sources/{sourceId}/identityUsage"
		                                .replace("{".concat("potentialRoleId", "}"), encodeURIComponent(String(potentialRoleId)))
		                                .replace("{".concat("sourceId", "}"), encodeURIComponent(String(sourceId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This method returns the potential role summaries for a role mining session.
		         * @summary Retrieves all potential role summaries
		         * @param {string} sessionId The role mining session id
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **createdDate**
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **createdById**: *eq, sw, co*  **createdByName**: *eq, sw, co*  **description**: *sw, co*  **endDate**: *le, lt*  **freshness**: *eq, ge, gt, le, lt*  **name**: *eq, sw, co*  **quality**: *eq, ge, gt, le, lt*  **startDate**: *ge, gt*  **saved**: *eq*  **type**: *eq*
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getPotentialRoleSummaries: function (sessionId, sorters, filters, offset, limit, count, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'sessionId' is not null or undefined
		                            (0, common_1.assertParamExists)('getPotentialRoleSummaries', 'sessionId', sessionId);
		                            localVarPath = "/role-mining-sessions/{sessionId}/potential-role-summaries"
		                                .replace("{".concat("sessionId", "}"), encodeURIComponent(String(sessionId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This method returns a specific potential role.
		         * @summary Retrieves a specific potential role
		         * @param {string} potentialRoleId A potential role id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getRoleMiningPotentialRole: function (potentialRoleId, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'potentialRoleId' is not null or undefined
		                            (0, common_1.assertParamExists)('getRoleMiningPotentialRole', 'potentialRoleId', potentialRoleId);
		                            localVarPath = "/role-mining-potential-roles/{potentialRoleId}"
		                                .replace("{".concat("potentialRoleId", "}"), encodeURIComponent(String(potentialRoleId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * The method retrieves a role mining session.
		         * @summary Get a role mining session
		         * @param {string} sessionId The role mining session id to be retrieved.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getRoleMiningSession: function (sessionId, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'sessionId' is not null or undefined
		                            (0, common_1.assertParamExists)('getRoleMiningSession', 'sessionId', sessionId);
		                            localVarPath = "/role-mining-sessions/{sessionId}"
		                                .replace("{".concat("sessionId", "}"), encodeURIComponent(String(sessionId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This method returns a role mining session status for a customer.
		         * @summary Get role mining session status state
		         * @param {string} sessionId The role mining session id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getRoleMiningSessionStatus: function (sessionId, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'sessionId' is not null or undefined
		                            (0, common_1.assertParamExists)('getRoleMiningSessionStatus', 'sessionId', sessionId);
		                            localVarPath = "/role-mining-sessions/{sessionId}/status"
		                                .replace("{".concat("sessionId", "}"), encodeURIComponent(String(sessionId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Returns all role mining sessions that match the query parameters
		         * @summary Retrieves all role mining sessions
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **saved**: *eq*  **name**: *eq, sw*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **createdBy, createdDate**
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getRoleMiningSessions: function (filters, sorters, offset, limit, count, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/role-mining-sessions";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This method returns all saved potential roles (draft roles).
		         * @summary Retrieves all saved potential roles
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters/) Sorting is supported for the following fields: **modified**
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getSavedPotentialRoles: function (sorters, offset, limit, count, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/role-mining-potential-roles/saved";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * The method updates an existing potential role using.  The following fields can be modified:  * `description`  * `name`  * `saved`   >**NOTE: All other fields cannot be modified.**
		         * @summary Update a potential role
		         * @param {string} sessionId The role mining session id
		         * @param {string} potentialRoleId The potential role summary id
		         * @param {Array<PatchPotentialRoleRequestInnerBeta>} patchPotentialRoleRequestInnerBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchPotentialRole: function (sessionId, potentialRoleId, patchPotentialRoleRequestInnerBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'sessionId' is not null or undefined
		                            (0, common_1.assertParamExists)('patchPotentialRole', 'sessionId', sessionId);
		                            // verify required parameter 'potentialRoleId' is not null or undefined
		                            (0, common_1.assertParamExists)('patchPotentialRole', 'potentialRoleId', potentialRoleId);
		                            // verify required parameter 'patchPotentialRoleRequestInnerBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('patchPotentialRole', 'patchPotentialRoleRequestInnerBeta', patchPotentialRoleRequestInnerBeta);
		                            localVarPath = "/role-mining-sessions/{sessionId}/potential-role-summaries/{potentialRoleId}"
		                                .replace("{".concat("sessionId", "}"), encodeURIComponent(String(sessionId)))
		                                .replace("{".concat("potentialRoleId", "}"), encodeURIComponent(String(potentialRoleId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PATCH' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json-patch+json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(patchPotentialRoleRequestInnerBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * The method updates an existing potential role using.  The following fields can be modified:  * `description`  * `name`  * `saved`   >**NOTE: All other fields cannot be modified.**
		         * @summary Update a potential role
		         * @param {string} sessionId The role mining session id
		         * @param {string} potentialRoleId The potential role summary id
		         * @param {Array<PatchPotentialRoleRequestInnerBeta>} patchPotentialRoleRequestInnerBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchPotentialRole_1: function (sessionId, potentialRoleId, patchPotentialRoleRequestInnerBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'sessionId' is not null or undefined
		                            (0, common_1.assertParamExists)('patchPotentialRole_1', 'sessionId', sessionId);
		                            // verify required parameter 'potentialRoleId' is not null or undefined
		                            (0, common_1.assertParamExists)('patchPotentialRole_1', 'potentialRoleId', potentialRoleId);
		                            // verify required parameter 'patchPotentialRoleRequestInnerBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('patchPotentialRole_1', 'patchPotentialRoleRequestInnerBeta', patchPotentialRoleRequestInnerBeta);
		                            localVarPath = "/role-mining-potential-roles/{potentialRoleId}"
		                                .replace("{".concat("sessionId", "}"), encodeURIComponent(String(sessionId)))
		                                .replace("{".concat("potentialRoleId", "}"), encodeURIComponent(String(potentialRoleId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PATCH' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json-patch+json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(patchPotentialRoleRequestInnerBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * The  method updates an existing role mining session using PATCH. Supports op in {\"replace\"} and changes to pruneThreshold and/or minNumIdentitiesInPotentialRole. The potential roles in this role mining session is then re-calculated.
		         * @summary Patch a role mining session
		         * @param {string} sessionId The role mining session id to be patched
		         * @param {Array<JsonPatchOperationBeta>} jsonPatchOperationBeta Replace pruneThreshold and/or minNumIdentitiesInPotentialRole in role mining session. Update saved status or saved name for a role mining session.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchRoleMiningSession: function (sessionId, jsonPatchOperationBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'sessionId' is not null or undefined
		                            (0, common_1.assertParamExists)('patchRoleMiningSession', 'sessionId', sessionId);
		                            // verify required parameter 'jsonPatchOperationBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('patchRoleMiningSession', 'jsonPatchOperationBeta', jsonPatchOperationBeta);
		                            localVarPath = "/role-mining-sessions/{sessionId}"
		                                .replace("{".concat("sessionId", "}"), encodeURIComponent(String(sessionId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PATCH' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json-patch+json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(jsonPatchOperationBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This endpoint adds or removes entitlements from an exclusion list for a potential role.
		         * @summary Edit entitlements for a potential role to exclude some entitlements
		         * @param {string} sessionId The role mining session id
		         * @param {string} potentialRoleId A potential role id in a role mining session
		         * @param {RoleMiningPotentialRoleEditEntitlementsBeta} roleMiningPotentialRoleEditEntitlementsBeta Role mining session parameters
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateEntitlementsPotentialRole: function (sessionId, potentialRoleId, roleMiningPotentialRoleEditEntitlementsBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'sessionId' is not null or undefined
		                            (0, common_1.assertParamExists)('updateEntitlementsPotentialRole', 'sessionId', sessionId);
		                            // verify required parameter 'potentialRoleId' is not null or undefined
		                            (0, common_1.assertParamExists)('updateEntitlementsPotentialRole', 'potentialRoleId', potentialRoleId);
		                            // verify required parameter 'roleMiningPotentialRoleEditEntitlementsBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('updateEntitlementsPotentialRole', 'roleMiningPotentialRoleEditEntitlementsBeta', roleMiningPotentialRoleEditEntitlementsBeta);
		                            localVarPath = "/role-mining-sessions/{sessionId}/potential-roles/{potentialRoleId}/edit-entitlements"
		                                .replace("{".concat("sessionId", "}"), encodeURIComponent(String(sessionId)))
		                                .replace("{".concat("potentialRoleId", "}"), encodeURIComponent(String(potentialRoleId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(roleMiningPotentialRoleEditEntitlementsBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.IAIRoleMiningBetaApiAxiosParamCreator = IAIRoleMiningBetaApiAxiosParamCreator;
		/**
		 * IAIRoleMiningBetaApi - functional programming interface
		 * @export
		 */
		var IAIRoleMiningBetaApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.IAIRoleMiningBetaApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * This method starts a job to provision a potential role
		         * @summary Create request to provision a potential role into an actual role.
		         * @param {string} sessionId The role mining session id
		         * @param {string} potentialRoleId A potential role id in a role mining session
		         * @param {number} [minEntitlementPopularity] Minimum popularity required for an entitlement to be included in the provisioned role.
		         * @param {boolean} [includeCommonAccess] Boolean determining whether common access entitlements will be included in the provisioned role.
		         * @param {RoleMiningPotentialRoleProvisionRequestBeta} [roleMiningPotentialRoleProvisionRequestBeta] Required information to create a new role
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createPotentialRoleProvisionRequest: function (sessionId, potentialRoleId, minEntitlementPopularity, includeCommonAccess, roleMiningPotentialRoleProvisionRequestBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.createPotentialRoleProvisionRequest(sessionId, potentialRoleId, minEntitlementPopularity, includeCommonAccess, roleMiningPotentialRoleProvisionRequestBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This submits a create role mining session request to the role mining application.
		         * @summary Create a role mining session
		         * @param {RoleMiningSessionDtoBeta} roleMiningSessionDtoBeta Role mining session parameters
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createRoleMiningSessions: function (roleMiningSessionDtoBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.createRoleMiningSessions(roleMiningSessionDtoBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This endpoint downloads a completed export of information for a potential role in a role mining session.
		         * @summary Export (download) details for a potential role in a role mining session
		         * @param {string} sessionId The role mining session id
		         * @param {string} potentialRoleId A potential role id in a role mining session
		         * @param {string} exportId The id of a previously run export job for this potential role
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        downloadRoleMiningPotentialRoleZip: function (sessionId, potentialRoleId, exportId, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.downloadRoleMiningPotentialRoleZip(sessionId, potentialRoleId, exportId, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This endpoint downloads all the information for a potential role in a role mining session. Includes identities and entitlements in the potential role.
		         * @summary Export (download) details for a potential role in a role mining session
		         * @param {string} sessionId The role mining session id
		         * @param {string} potentialRoleId A potential role id in a role mining session
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        exportRoleMiningPotentialRole: function (sessionId, potentialRoleId, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.exportRoleMiningPotentialRole(sessionId, potentialRoleId, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This endpoint uploads all the information for a potential role in a role mining session to S3 as a downloadable zip archive.  Includes identities and entitlements in the potential role.
		         * @summary Asynchronously export details for a potential role in a role mining session and upload to S3
		         * @param {string} sessionId The role mining session id
		         * @param {string} potentialRoleId A potential role id in a role mining session
		         * @param {RoleMiningPotentialRoleExportRequestBeta} [roleMiningPotentialRoleExportRequestBeta]
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        exportRoleMiningPotentialRoleAsync: function (sessionId, potentialRoleId, roleMiningPotentialRoleExportRequestBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.exportRoleMiningPotentialRoleAsync(sessionId, potentialRoleId, roleMiningPotentialRoleExportRequestBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This endpoint retrieves information about the current status of a potential role export.
		         * @summary Retrieve status of a potential role export job
		         * @param {string} sessionId The role mining session id
		         * @param {string} potentialRoleId A potential role id in a role mining session
		         * @param {string} exportId The id of a previously run export job for this potential role
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        exportRoleMiningPotentialRoleStatus: function (sessionId, potentialRoleId, exportId, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.exportRoleMiningPotentialRoleStatus(sessionId, potentialRoleId, exportId, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Returns all potential role summaries that match the query parameters
		         * @summary Retrieves all potential role summaries
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **createdDate, identityCount, entitlementCount, freshness, quality**
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **createdById**: *eq, sw, co*  **createdByName**: *eq, sw, co*  **description**: *sw, co*  **endDate**: *le, lt*  **freshness**: *eq, ge, gt, le, lt*  **name**: *eq, sw, co, ge, gt, le, lt*  **quality**: *eq, ge, gt, le, lt*  **startDate**: *ge, gt*  **saved**: *eq*  **type**: *eq, ge, gt, le, lt*  **scopingMethod**: *eq*  **sessionState**: *eq*  **identityAttribute**: *co*
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getAllPotentialRoleSummaries: function (sorters, filters, offset, limit, count, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getAllPotentialRoleSummaries(sorters, filters, offset, limit, count, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This method returns entitlement popularity distribution for a potential role in a role mining session.
		         * @summary Retrieves entitlement popularity distribution for a potential role in a role mining session
		         * @param {string} sessionId The role mining session id
		         * @param {string} potentialRoleId A potential role id in a role mining session
		         * @param {boolean} [includeCommonAccess] Boolean determining whether common access entitlements will be included or not
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getEntitlementDistributionPotentialRole: function (sessionId, potentialRoleId, includeCommonAccess, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getEntitlementDistributionPotentialRole(sessionId, potentialRoleId, includeCommonAccess, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This method returns entitlements for a potential role in a role mining session.
		         * @summary Retrieves entitlements for a potential role in a role mining session
		         * @param {string} sessionId The role mining session id
		         * @param {string} potentialRoleId A potential role id in a role mining session
		         * @param {boolean} [includeCommonAccess] Boolean determining whether common access entitlements will be included or not
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **popularity**  The default sort is **popularity** in descending order.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **applicationName**: *sw*  **entitlementRef.name**: *sw*
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getEntitlementsPotentialRole: function (sessionId, potentialRoleId, includeCommonAccess, sorters, filters, offset, limit, count, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getEntitlementsPotentialRole(sessionId, potentialRoleId, includeCommonAccess, sorters, filters, offset, limit, count, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This method returns excluded entitlements for a potential role in a role mining session.
		         * @summary Retrieves excluded entitlements for a potential role in a role mining session
		         * @param {string} sessionId The role mining session id
		         * @param {string} potentialRoleId A potential role id in a role mining session
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **popularity**
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **applicationName**: *sw*  **entitlementRef.name**: *sw*
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getExcludedEntitlementsPotentialRole: function (sessionId, potentialRoleId, sorters, filters, offset, limit, count, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getExcludedEntitlementsPotentialRole(sessionId, potentialRoleId, sorters, filters, offset, limit, count, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This method returns identities for a potential role in a role mining session.
		         * @summary Retrieves identities for a potential role in a role mining session
		         * @param {string} sessionId The role mining session id
		         * @param {string} potentialRoleId A potential role id in a role mining session
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name**
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **name**: *sw*
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getIdentitiesPotentialRole: function (sessionId, potentialRoleId, sorters, filters, offset, limit, count, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getIdentitiesPotentialRole(sessionId, potentialRoleId, sorters, filters, offset, limit, count, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This method returns a specific potential role for a role mining session.
		         * @summary Retrieves a specific potential role
		         * @param {string} sessionId The role mining session id
		         * @param {string} potentialRoleId A potential role id in a role mining session
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getPotentialRole: function (sessionId, potentialRoleId, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getPotentialRole(sessionId, potentialRoleId, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This method returns the applications of a potential role for a role mining session.
		         * @summary Retrieves the applications of a potential role for a role mining session
		         * @param {string} sessionId The role mining session id
		         * @param {string} potentialRoleId A potential role id in a role mining session
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getPotentialRoleApplications: function (sessionId, potentialRoleId, offset, limit, count, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getPotentialRoleApplications(sessionId, potentialRoleId, offset, limit, count, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This method returns source usageCount (as number of days in the last 90 days) for each identity in a potential role.
		         * @summary Retrieves potential role source usage
		         * @param {string} potentialRoleId A potential role id
		         * @param {string} sourceId A source id
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters/) Sorting is supported for the following fields: **displayName, email, usageCount**
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getPotentialRoleSourceIdentityUsage: function (potentialRoleId, sourceId, sorters, offset, limit, count, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getPotentialRoleSourceIdentityUsage(potentialRoleId, sourceId, sorters, offset, limit, count, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This method returns the potential role summaries for a role mining session.
		         * @summary Retrieves all potential role summaries
		         * @param {string} sessionId The role mining session id
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **createdDate**
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **createdById**: *eq, sw, co*  **createdByName**: *eq, sw, co*  **description**: *sw, co*  **endDate**: *le, lt*  **freshness**: *eq, ge, gt, le, lt*  **name**: *eq, sw, co*  **quality**: *eq, ge, gt, le, lt*  **startDate**: *ge, gt*  **saved**: *eq*  **type**: *eq*
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getPotentialRoleSummaries: function (sessionId, sorters, filters, offset, limit, count, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getPotentialRoleSummaries(sessionId, sorters, filters, offset, limit, count, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This method returns a specific potential role.
		         * @summary Retrieves a specific potential role
		         * @param {string} potentialRoleId A potential role id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getRoleMiningPotentialRole: function (potentialRoleId, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getRoleMiningPotentialRole(potentialRoleId, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * The method retrieves a role mining session.
		         * @summary Get a role mining session
		         * @param {string} sessionId The role mining session id to be retrieved.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getRoleMiningSession: function (sessionId, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getRoleMiningSession(sessionId, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This method returns a role mining session status for a customer.
		         * @summary Get role mining session status state
		         * @param {string} sessionId The role mining session id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getRoleMiningSessionStatus: function (sessionId, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getRoleMiningSessionStatus(sessionId, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Returns all role mining sessions that match the query parameters
		         * @summary Retrieves all role mining sessions
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **saved**: *eq*  **name**: *eq, sw*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **createdBy, createdDate**
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getRoleMiningSessions: function (filters, sorters, offset, limit, count, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getRoleMiningSessions(filters, sorters, offset, limit, count, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This method returns all saved potential roles (draft roles).
		         * @summary Retrieves all saved potential roles
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters/) Sorting is supported for the following fields: **modified**
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getSavedPotentialRoles: function (sorters, offset, limit, count, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getSavedPotentialRoles(sorters, offset, limit, count, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * The method updates an existing potential role using.  The following fields can be modified:  * `description`  * `name`  * `saved`   >**NOTE: All other fields cannot be modified.**
		         * @summary Update a potential role
		         * @param {string} sessionId The role mining session id
		         * @param {string} potentialRoleId The potential role summary id
		         * @param {Array<PatchPotentialRoleRequestInnerBeta>} patchPotentialRoleRequestInnerBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchPotentialRole: function (sessionId, potentialRoleId, patchPotentialRoleRequestInnerBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.patchPotentialRole(sessionId, potentialRoleId, patchPotentialRoleRequestInnerBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * The method updates an existing potential role using.  The following fields can be modified:  * `description`  * `name`  * `saved`   >**NOTE: All other fields cannot be modified.**
		         * @summary Update a potential role
		         * @param {string} sessionId The role mining session id
		         * @param {string} potentialRoleId The potential role summary id
		         * @param {Array<PatchPotentialRoleRequestInnerBeta>} patchPotentialRoleRequestInnerBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchPotentialRole_1: function (sessionId, potentialRoleId, patchPotentialRoleRequestInnerBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.patchPotentialRole_1(sessionId, potentialRoleId, patchPotentialRoleRequestInnerBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * The  method updates an existing role mining session using PATCH. Supports op in {\"replace\"} and changes to pruneThreshold and/or minNumIdentitiesInPotentialRole. The potential roles in this role mining session is then re-calculated.
		         * @summary Patch a role mining session
		         * @param {string} sessionId The role mining session id to be patched
		         * @param {Array<JsonPatchOperationBeta>} jsonPatchOperationBeta Replace pruneThreshold and/or minNumIdentitiesInPotentialRole in role mining session. Update saved status or saved name for a role mining session.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchRoleMiningSession: function (sessionId, jsonPatchOperationBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.patchRoleMiningSession(sessionId, jsonPatchOperationBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This endpoint adds or removes entitlements from an exclusion list for a potential role.
		         * @summary Edit entitlements for a potential role to exclude some entitlements
		         * @param {string} sessionId The role mining session id
		         * @param {string} potentialRoleId A potential role id in a role mining session
		         * @param {RoleMiningPotentialRoleEditEntitlementsBeta} roleMiningPotentialRoleEditEntitlementsBeta Role mining session parameters
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateEntitlementsPotentialRole: function (sessionId, potentialRoleId, roleMiningPotentialRoleEditEntitlementsBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.updateEntitlementsPotentialRole(sessionId, potentialRoleId, roleMiningPotentialRoleEditEntitlementsBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.IAIRoleMiningBetaApiFp = IAIRoleMiningBetaApiFp;
		/**
		 * IAIRoleMiningBetaApi - factory interface
		 * @export
		 */
		var IAIRoleMiningBetaApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.IAIRoleMiningBetaApiFp)(configuration);
		    return {
		        /**
		         * This method starts a job to provision a potential role
		         * @summary Create request to provision a potential role into an actual role.
		         * @param {string} sessionId The role mining session id
		         * @param {string} potentialRoleId A potential role id in a role mining session
		         * @param {number} [minEntitlementPopularity] Minimum popularity required for an entitlement to be included in the provisioned role.
		         * @param {boolean} [includeCommonAccess] Boolean determining whether common access entitlements will be included in the provisioned role.
		         * @param {RoleMiningPotentialRoleProvisionRequestBeta} [roleMiningPotentialRoleProvisionRequestBeta] Required information to create a new role
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createPotentialRoleProvisionRequest: function (sessionId, potentialRoleId, minEntitlementPopularity, includeCommonAccess, roleMiningPotentialRoleProvisionRequestBeta, axiosOptions) {
		            return localVarFp.createPotentialRoleProvisionRequest(sessionId, potentialRoleId, minEntitlementPopularity, includeCommonAccess, roleMiningPotentialRoleProvisionRequestBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This submits a create role mining session request to the role mining application.
		         * @summary Create a role mining session
		         * @param {RoleMiningSessionDtoBeta} roleMiningSessionDtoBeta Role mining session parameters
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createRoleMiningSessions: function (roleMiningSessionDtoBeta, axiosOptions) {
		            return localVarFp.createRoleMiningSessions(roleMiningSessionDtoBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This endpoint downloads a completed export of information for a potential role in a role mining session.
		         * @summary Export (download) details for a potential role in a role mining session
		         * @param {string} sessionId The role mining session id
		         * @param {string} potentialRoleId A potential role id in a role mining session
		         * @param {string} exportId The id of a previously run export job for this potential role
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        downloadRoleMiningPotentialRoleZip: function (sessionId, potentialRoleId, exportId, axiosOptions) {
		            return localVarFp.downloadRoleMiningPotentialRoleZip(sessionId, potentialRoleId, exportId, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This endpoint downloads all the information for a potential role in a role mining session. Includes identities and entitlements in the potential role.
		         * @summary Export (download) details for a potential role in a role mining session
		         * @param {string} sessionId The role mining session id
		         * @param {string} potentialRoleId A potential role id in a role mining session
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        exportRoleMiningPotentialRole: function (sessionId, potentialRoleId, axiosOptions) {
		            return localVarFp.exportRoleMiningPotentialRole(sessionId, potentialRoleId, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This endpoint uploads all the information for a potential role in a role mining session to S3 as a downloadable zip archive.  Includes identities and entitlements in the potential role.
		         * @summary Asynchronously export details for a potential role in a role mining session and upload to S3
		         * @param {string} sessionId The role mining session id
		         * @param {string} potentialRoleId A potential role id in a role mining session
		         * @param {RoleMiningPotentialRoleExportRequestBeta} [roleMiningPotentialRoleExportRequestBeta]
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        exportRoleMiningPotentialRoleAsync: function (sessionId, potentialRoleId, roleMiningPotentialRoleExportRequestBeta, axiosOptions) {
		            return localVarFp.exportRoleMiningPotentialRoleAsync(sessionId, potentialRoleId, roleMiningPotentialRoleExportRequestBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This endpoint retrieves information about the current status of a potential role export.
		         * @summary Retrieve status of a potential role export job
		         * @param {string} sessionId The role mining session id
		         * @param {string} potentialRoleId A potential role id in a role mining session
		         * @param {string} exportId The id of a previously run export job for this potential role
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        exportRoleMiningPotentialRoleStatus: function (sessionId, potentialRoleId, exportId, axiosOptions) {
		            return localVarFp.exportRoleMiningPotentialRoleStatus(sessionId, potentialRoleId, exportId, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Returns all potential role summaries that match the query parameters
		         * @summary Retrieves all potential role summaries
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **createdDate, identityCount, entitlementCount, freshness, quality**
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **createdById**: *eq, sw, co*  **createdByName**: *eq, sw, co*  **description**: *sw, co*  **endDate**: *le, lt*  **freshness**: *eq, ge, gt, le, lt*  **name**: *eq, sw, co, ge, gt, le, lt*  **quality**: *eq, ge, gt, le, lt*  **startDate**: *ge, gt*  **saved**: *eq*  **type**: *eq, ge, gt, le, lt*  **scopingMethod**: *eq*  **sessionState**: *eq*  **identityAttribute**: *co*
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getAllPotentialRoleSummaries: function (sorters, filters, offset, limit, count, axiosOptions) {
		            return localVarFp.getAllPotentialRoleSummaries(sorters, filters, offset, limit, count, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This method returns entitlement popularity distribution for a potential role in a role mining session.
		         * @summary Retrieves entitlement popularity distribution for a potential role in a role mining session
		         * @param {string} sessionId The role mining session id
		         * @param {string} potentialRoleId A potential role id in a role mining session
		         * @param {boolean} [includeCommonAccess] Boolean determining whether common access entitlements will be included or not
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getEntitlementDistributionPotentialRole: function (sessionId, potentialRoleId, includeCommonAccess, axiosOptions) {
		            return localVarFp.getEntitlementDistributionPotentialRole(sessionId, potentialRoleId, includeCommonAccess, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This method returns entitlements for a potential role in a role mining session.
		         * @summary Retrieves entitlements for a potential role in a role mining session
		         * @param {string} sessionId The role mining session id
		         * @param {string} potentialRoleId A potential role id in a role mining session
		         * @param {boolean} [includeCommonAccess] Boolean determining whether common access entitlements will be included or not
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **popularity**  The default sort is **popularity** in descending order.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **applicationName**: *sw*  **entitlementRef.name**: *sw*
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getEntitlementsPotentialRole: function (sessionId, potentialRoleId, includeCommonAccess, sorters, filters, offset, limit, count, axiosOptions) {
		            return localVarFp.getEntitlementsPotentialRole(sessionId, potentialRoleId, includeCommonAccess, sorters, filters, offset, limit, count, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This method returns excluded entitlements for a potential role in a role mining session.
		         * @summary Retrieves excluded entitlements for a potential role in a role mining session
		         * @param {string} sessionId The role mining session id
		         * @param {string} potentialRoleId A potential role id in a role mining session
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **popularity**
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **applicationName**: *sw*  **entitlementRef.name**: *sw*
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getExcludedEntitlementsPotentialRole: function (sessionId, potentialRoleId, sorters, filters, offset, limit, count, axiosOptions) {
		            return localVarFp.getExcludedEntitlementsPotentialRole(sessionId, potentialRoleId, sorters, filters, offset, limit, count, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This method returns identities for a potential role in a role mining session.
		         * @summary Retrieves identities for a potential role in a role mining session
		         * @param {string} sessionId The role mining session id
		         * @param {string} potentialRoleId A potential role id in a role mining session
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name**
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **name**: *sw*
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getIdentitiesPotentialRole: function (sessionId, potentialRoleId, sorters, filters, offset, limit, count, axiosOptions) {
		            return localVarFp.getIdentitiesPotentialRole(sessionId, potentialRoleId, sorters, filters, offset, limit, count, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This method returns a specific potential role for a role mining session.
		         * @summary Retrieves a specific potential role
		         * @param {string} sessionId The role mining session id
		         * @param {string} potentialRoleId A potential role id in a role mining session
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getPotentialRole: function (sessionId, potentialRoleId, axiosOptions) {
		            return localVarFp.getPotentialRole(sessionId, potentialRoleId, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This method returns the applications of a potential role for a role mining session.
		         * @summary Retrieves the applications of a potential role for a role mining session
		         * @param {string} sessionId The role mining session id
		         * @param {string} potentialRoleId A potential role id in a role mining session
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getPotentialRoleApplications: function (sessionId, potentialRoleId, offset, limit, count, axiosOptions) {
		            return localVarFp.getPotentialRoleApplications(sessionId, potentialRoleId, offset, limit, count, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This method returns source usageCount (as number of days in the last 90 days) for each identity in a potential role.
		         * @summary Retrieves potential role source usage
		         * @param {string} potentialRoleId A potential role id
		         * @param {string} sourceId A source id
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters/) Sorting is supported for the following fields: **displayName, email, usageCount**
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getPotentialRoleSourceIdentityUsage: function (potentialRoleId, sourceId, sorters, offset, limit, count, axiosOptions) {
		            return localVarFp.getPotentialRoleSourceIdentityUsage(potentialRoleId, sourceId, sorters, offset, limit, count, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This method returns the potential role summaries for a role mining session.
		         * @summary Retrieves all potential role summaries
		         * @param {string} sessionId The role mining session id
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **createdDate**
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **createdById**: *eq, sw, co*  **createdByName**: *eq, sw, co*  **description**: *sw, co*  **endDate**: *le, lt*  **freshness**: *eq, ge, gt, le, lt*  **name**: *eq, sw, co*  **quality**: *eq, ge, gt, le, lt*  **startDate**: *ge, gt*  **saved**: *eq*  **type**: *eq*
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getPotentialRoleSummaries: function (sessionId, sorters, filters, offset, limit, count, axiosOptions) {
		            return localVarFp.getPotentialRoleSummaries(sessionId, sorters, filters, offset, limit, count, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This method returns a specific potential role.
		         * @summary Retrieves a specific potential role
		         * @param {string} potentialRoleId A potential role id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getRoleMiningPotentialRole: function (potentialRoleId, axiosOptions) {
		            return localVarFp.getRoleMiningPotentialRole(potentialRoleId, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * The method retrieves a role mining session.
		         * @summary Get a role mining session
		         * @param {string} sessionId The role mining session id to be retrieved.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getRoleMiningSession: function (sessionId, axiosOptions) {
		            return localVarFp.getRoleMiningSession(sessionId, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This method returns a role mining session status for a customer.
		         * @summary Get role mining session status state
		         * @param {string} sessionId The role mining session id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getRoleMiningSessionStatus: function (sessionId, axiosOptions) {
		            return localVarFp.getRoleMiningSessionStatus(sessionId, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Returns all role mining sessions that match the query parameters
		         * @summary Retrieves all role mining sessions
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **saved**: *eq*  **name**: *eq, sw*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **createdBy, createdDate**
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getRoleMiningSessions: function (filters, sorters, offset, limit, count, axiosOptions) {
		            return localVarFp.getRoleMiningSessions(filters, sorters, offset, limit, count, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This method returns all saved potential roles (draft roles).
		         * @summary Retrieves all saved potential roles
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters/) Sorting is supported for the following fields: **modified**
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getSavedPotentialRoles: function (sorters, offset, limit, count, axiosOptions) {
		            return localVarFp.getSavedPotentialRoles(sorters, offset, limit, count, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * The method updates an existing potential role using.  The following fields can be modified:  * `description`  * `name`  * `saved`   >**NOTE: All other fields cannot be modified.**
		         * @summary Update a potential role
		         * @param {string} sessionId The role mining session id
		         * @param {string} potentialRoleId The potential role summary id
		         * @param {Array<PatchPotentialRoleRequestInnerBeta>} patchPotentialRoleRequestInnerBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchPotentialRole: function (sessionId, potentialRoleId, patchPotentialRoleRequestInnerBeta, axiosOptions) {
		            return localVarFp.patchPotentialRole(sessionId, potentialRoleId, patchPotentialRoleRequestInnerBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * The method updates an existing potential role using.  The following fields can be modified:  * `description`  * `name`  * `saved`   >**NOTE: All other fields cannot be modified.**
		         * @summary Update a potential role
		         * @param {string} sessionId The role mining session id
		         * @param {string} potentialRoleId The potential role summary id
		         * @param {Array<PatchPotentialRoleRequestInnerBeta>} patchPotentialRoleRequestInnerBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchPotentialRole_1: function (sessionId, potentialRoleId, patchPotentialRoleRequestInnerBeta, axiosOptions) {
		            return localVarFp.patchPotentialRole_1(sessionId, potentialRoleId, patchPotentialRoleRequestInnerBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * The  method updates an existing role mining session using PATCH. Supports op in {\"replace\"} and changes to pruneThreshold and/or minNumIdentitiesInPotentialRole. The potential roles in this role mining session is then re-calculated.
		         * @summary Patch a role mining session
		         * @param {string} sessionId The role mining session id to be patched
		         * @param {Array<JsonPatchOperationBeta>} jsonPatchOperationBeta Replace pruneThreshold and/or minNumIdentitiesInPotentialRole in role mining session. Update saved status or saved name for a role mining session.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchRoleMiningSession: function (sessionId, jsonPatchOperationBeta, axiosOptions) {
		            return localVarFp.patchRoleMiningSession(sessionId, jsonPatchOperationBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This endpoint adds or removes entitlements from an exclusion list for a potential role.
		         * @summary Edit entitlements for a potential role to exclude some entitlements
		         * @param {string} sessionId The role mining session id
		         * @param {string} potentialRoleId A potential role id in a role mining session
		         * @param {RoleMiningPotentialRoleEditEntitlementsBeta} roleMiningPotentialRoleEditEntitlementsBeta Role mining session parameters
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateEntitlementsPotentialRole: function (sessionId, potentialRoleId, roleMiningPotentialRoleEditEntitlementsBeta, axiosOptions) {
		            return localVarFp.updateEntitlementsPotentialRole(sessionId, potentialRoleId, roleMiningPotentialRoleEditEntitlementsBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.IAIRoleMiningBetaApiFactory = IAIRoleMiningBetaApiFactory;
		/**
		 * IAIRoleMiningBetaApi - object-oriented interface
		 * @export
		 * @class IAIRoleMiningBetaApi
		 * @extends {BaseAPI}
		 */
		var IAIRoleMiningBetaApi = /** @class */ (function (_super) {
		    __extends(IAIRoleMiningBetaApi, _super);
		    function IAIRoleMiningBetaApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * This method starts a job to provision a potential role
		     * @summary Create request to provision a potential role into an actual role.
		     * @param {IAIRoleMiningBetaApiCreatePotentialRoleProvisionRequestRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IAIRoleMiningBetaApi
		     */
		    IAIRoleMiningBetaApi.prototype.createPotentialRoleProvisionRequest = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.IAIRoleMiningBetaApiFp)(this.configuration).createPotentialRoleProvisionRequest(requestParameters.sessionId, requestParameters.potentialRoleId, requestParameters.minEntitlementPopularity, requestParameters.includeCommonAccess, requestParameters.roleMiningPotentialRoleProvisionRequestBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This submits a create role mining session request to the role mining application.
		     * @summary Create a role mining session
		     * @param {IAIRoleMiningBetaApiCreateRoleMiningSessionsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IAIRoleMiningBetaApi
		     */
		    IAIRoleMiningBetaApi.prototype.createRoleMiningSessions = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.IAIRoleMiningBetaApiFp)(this.configuration).createRoleMiningSessions(requestParameters.roleMiningSessionDtoBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This endpoint downloads a completed export of information for a potential role in a role mining session.
		     * @summary Export (download) details for a potential role in a role mining session
		     * @param {IAIRoleMiningBetaApiDownloadRoleMiningPotentialRoleZipRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IAIRoleMiningBetaApi
		     */
		    IAIRoleMiningBetaApi.prototype.downloadRoleMiningPotentialRoleZip = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.IAIRoleMiningBetaApiFp)(this.configuration).downloadRoleMiningPotentialRoleZip(requestParameters.sessionId, requestParameters.potentialRoleId, requestParameters.exportId, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This endpoint downloads all the information for a potential role in a role mining session. Includes identities and entitlements in the potential role.
		     * @summary Export (download) details for a potential role in a role mining session
		     * @param {IAIRoleMiningBetaApiExportRoleMiningPotentialRoleRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IAIRoleMiningBetaApi
		     */
		    IAIRoleMiningBetaApi.prototype.exportRoleMiningPotentialRole = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.IAIRoleMiningBetaApiFp)(this.configuration).exportRoleMiningPotentialRole(requestParameters.sessionId, requestParameters.potentialRoleId, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This endpoint uploads all the information for a potential role in a role mining session to S3 as a downloadable zip archive.  Includes identities and entitlements in the potential role.
		     * @summary Asynchronously export details for a potential role in a role mining session and upload to S3
		     * @param {IAIRoleMiningBetaApiExportRoleMiningPotentialRoleAsyncRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IAIRoleMiningBetaApi
		     */
		    IAIRoleMiningBetaApi.prototype.exportRoleMiningPotentialRoleAsync = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.IAIRoleMiningBetaApiFp)(this.configuration).exportRoleMiningPotentialRoleAsync(requestParameters.sessionId, requestParameters.potentialRoleId, requestParameters.roleMiningPotentialRoleExportRequestBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This endpoint retrieves information about the current status of a potential role export.
		     * @summary Retrieve status of a potential role export job
		     * @param {IAIRoleMiningBetaApiExportRoleMiningPotentialRoleStatusRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IAIRoleMiningBetaApi
		     */
		    IAIRoleMiningBetaApi.prototype.exportRoleMiningPotentialRoleStatus = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.IAIRoleMiningBetaApiFp)(this.configuration).exportRoleMiningPotentialRoleStatus(requestParameters.sessionId, requestParameters.potentialRoleId, requestParameters.exportId, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Returns all potential role summaries that match the query parameters
		     * @summary Retrieves all potential role summaries
		     * @param {IAIRoleMiningBetaApiGetAllPotentialRoleSummariesRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IAIRoleMiningBetaApi
		     */
		    IAIRoleMiningBetaApi.prototype.getAllPotentialRoleSummaries = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.IAIRoleMiningBetaApiFp)(this.configuration).getAllPotentialRoleSummaries(requestParameters.sorters, requestParameters.filters, requestParameters.offset, requestParameters.limit, requestParameters.count, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This method returns entitlement popularity distribution for a potential role in a role mining session.
		     * @summary Retrieves entitlement popularity distribution for a potential role in a role mining session
		     * @param {IAIRoleMiningBetaApiGetEntitlementDistributionPotentialRoleRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IAIRoleMiningBetaApi
		     */
		    IAIRoleMiningBetaApi.prototype.getEntitlementDistributionPotentialRole = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.IAIRoleMiningBetaApiFp)(this.configuration).getEntitlementDistributionPotentialRole(requestParameters.sessionId, requestParameters.potentialRoleId, requestParameters.includeCommonAccess, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This method returns entitlements for a potential role in a role mining session.
		     * @summary Retrieves entitlements for a potential role in a role mining session
		     * @param {IAIRoleMiningBetaApiGetEntitlementsPotentialRoleRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IAIRoleMiningBetaApi
		     */
		    IAIRoleMiningBetaApi.prototype.getEntitlementsPotentialRole = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.IAIRoleMiningBetaApiFp)(this.configuration).getEntitlementsPotentialRole(requestParameters.sessionId, requestParameters.potentialRoleId, requestParameters.includeCommonAccess, requestParameters.sorters, requestParameters.filters, requestParameters.offset, requestParameters.limit, requestParameters.count, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This method returns excluded entitlements for a potential role in a role mining session.
		     * @summary Retrieves excluded entitlements for a potential role in a role mining session
		     * @param {IAIRoleMiningBetaApiGetExcludedEntitlementsPotentialRoleRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IAIRoleMiningBetaApi
		     */
		    IAIRoleMiningBetaApi.prototype.getExcludedEntitlementsPotentialRole = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.IAIRoleMiningBetaApiFp)(this.configuration).getExcludedEntitlementsPotentialRole(requestParameters.sessionId, requestParameters.potentialRoleId, requestParameters.sorters, requestParameters.filters, requestParameters.offset, requestParameters.limit, requestParameters.count, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This method returns identities for a potential role in a role mining session.
		     * @summary Retrieves identities for a potential role in a role mining session
		     * @param {IAIRoleMiningBetaApiGetIdentitiesPotentialRoleRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IAIRoleMiningBetaApi
		     */
		    IAIRoleMiningBetaApi.prototype.getIdentitiesPotentialRole = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.IAIRoleMiningBetaApiFp)(this.configuration).getIdentitiesPotentialRole(requestParameters.sessionId, requestParameters.potentialRoleId, requestParameters.sorters, requestParameters.filters, requestParameters.offset, requestParameters.limit, requestParameters.count, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This method returns a specific potential role for a role mining session.
		     * @summary Retrieves a specific potential role
		     * @param {IAIRoleMiningBetaApiGetPotentialRoleRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IAIRoleMiningBetaApi
		     */
		    IAIRoleMiningBetaApi.prototype.getPotentialRole = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.IAIRoleMiningBetaApiFp)(this.configuration).getPotentialRole(requestParameters.sessionId, requestParameters.potentialRoleId, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This method returns the applications of a potential role for a role mining session.
		     * @summary Retrieves the applications of a potential role for a role mining session
		     * @param {IAIRoleMiningBetaApiGetPotentialRoleApplicationsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IAIRoleMiningBetaApi
		     */
		    IAIRoleMiningBetaApi.prototype.getPotentialRoleApplications = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.IAIRoleMiningBetaApiFp)(this.configuration).getPotentialRoleApplications(requestParameters.sessionId, requestParameters.potentialRoleId, requestParameters.offset, requestParameters.limit, requestParameters.count, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This method returns source usageCount (as number of days in the last 90 days) for each identity in a potential role.
		     * @summary Retrieves potential role source usage
		     * @param {IAIRoleMiningBetaApiGetPotentialRoleSourceIdentityUsageRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IAIRoleMiningBetaApi
		     */
		    IAIRoleMiningBetaApi.prototype.getPotentialRoleSourceIdentityUsage = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.IAIRoleMiningBetaApiFp)(this.configuration).getPotentialRoleSourceIdentityUsage(requestParameters.potentialRoleId, requestParameters.sourceId, requestParameters.sorters, requestParameters.offset, requestParameters.limit, requestParameters.count, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This method returns the potential role summaries for a role mining session.
		     * @summary Retrieves all potential role summaries
		     * @param {IAIRoleMiningBetaApiGetPotentialRoleSummariesRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IAIRoleMiningBetaApi
		     */
		    IAIRoleMiningBetaApi.prototype.getPotentialRoleSummaries = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.IAIRoleMiningBetaApiFp)(this.configuration).getPotentialRoleSummaries(requestParameters.sessionId, requestParameters.sorters, requestParameters.filters, requestParameters.offset, requestParameters.limit, requestParameters.count, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This method returns a specific potential role.
		     * @summary Retrieves a specific potential role
		     * @param {IAIRoleMiningBetaApiGetRoleMiningPotentialRoleRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IAIRoleMiningBetaApi
		     */
		    IAIRoleMiningBetaApi.prototype.getRoleMiningPotentialRole = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.IAIRoleMiningBetaApiFp)(this.configuration).getRoleMiningPotentialRole(requestParameters.potentialRoleId, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * The method retrieves a role mining session.
		     * @summary Get a role mining session
		     * @param {IAIRoleMiningBetaApiGetRoleMiningSessionRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IAIRoleMiningBetaApi
		     */
		    IAIRoleMiningBetaApi.prototype.getRoleMiningSession = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.IAIRoleMiningBetaApiFp)(this.configuration).getRoleMiningSession(requestParameters.sessionId, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This method returns a role mining session status for a customer.
		     * @summary Get role mining session status state
		     * @param {IAIRoleMiningBetaApiGetRoleMiningSessionStatusRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IAIRoleMiningBetaApi
		     */
		    IAIRoleMiningBetaApi.prototype.getRoleMiningSessionStatus = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.IAIRoleMiningBetaApiFp)(this.configuration).getRoleMiningSessionStatus(requestParameters.sessionId, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Returns all role mining sessions that match the query parameters
		     * @summary Retrieves all role mining sessions
		     * @param {IAIRoleMiningBetaApiGetRoleMiningSessionsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IAIRoleMiningBetaApi
		     */
		    IAIRoleMiningBetaApi.prototype.getRoleMiningSessions = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.IAIRoleMiningBetaApiFp)(this.configuration).getRoleMiningSessions(requestParameters.filters, requestParameters.sorters, requestParameters.offset, requestParameters.limit, requestParameters.count, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This method returns all saved potential roles (draft roles).
		     * @summary Retrieves all saved potential roles
		     * @param {IAIRoleMiningBetaApiGetSavedPotentialRolesRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IAIRoleMiningBetaApi
		     */
		    IAIRoleMiningBetaApi.prototype.getSavedPotentialRoles = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.IAIRoleMiningBetaApiFp)(this.configuration).getSavedPotentialRoles(requestParameters.sorters, requestParameters.offset, requestParameters.limit, requestParameters.count, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * The method updates an existing potential role using.  The following fields can be modified:  * `description`  * `name`  * `saved`   >**NOTE: All other fields cannot be modified.**
		     * @summary Update a potential role
		     * @param {IAIRoleMiningBetaApiPatchPotentialRoleRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IAIRoleMiningBetaApi
		     */
		    IAIRoleMiningBetaApi.prototype.patchPotentialRole = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.IAIRoleMiningBetaApiFp)(this.configuration).patchPotentialRole(requestParameters.sessionId, requestParameters.potentialRoleId, requestParameters.patchPotentialRoleRequestInnerBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * The method updates an existing potential role using.  The following fields can be modified:  * `description`  * `name`  * `saved`   >**NOTE: All other fields cannot be modified.**
		     * @summary Update a potential role
		     * @param {IAIRoleMiningBetaApiPatchPotentialRole0Request} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IAIRoleMiningBetaApi
		     */
		    IAIRoleMiningBetaApi.prototype.patchPotentialRole_1 = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.IAIRoleMiningBetaApiFp)(this.configuration).patchPotentialRole_1(requestParameters.sessionId, requestParameters.potentialRoleId, requestParameters.patchPotentialRoleRequestInnerBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * The  method updates an existing role mining session using PATCH. Supports op in {\"replace\"} and changes to pruneThreshold and/or minNumIdentitiesInPotentialRole. The potential roles in this role mining session is then re-calculated.
		     * @summary Patch a role mining session
		     * @param {IAIRoleMiningBetaApiPatchRoleMiningSessionRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IAIRoleMiningBetaApi
		     */
		    IAIRoleMiningBetaApi.prototype.patchRoleMiningSession = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.IAIRoleMiningBetaApiFp)(this.configuration).patchRoleMiningSession(requestParameters.sessionId, requestParameters.jsonPatchOperationBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This endpoint adds or removes entitlements from an exclusion list for a potential role.
		     * @summary Edit entitlements for a potential role to exclude some entitlements
		     * @param {IAIRoleMiningBetaApiUpdateEntitlementsPotentialRoleRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IAIRoleMiningBetaApi
		     */
		    IAIRoleMiningBetaApi.prototype.updateEntitlementsPotentialRole = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.IAIRoleMiningBetaApiFp)(this.configuration).updateEntitlementsPotentialRole(requestParameters.sessionId, requestParameters.potentialRoleId, requestParameters.roleMiningPotentialRoleEditEntitlementsBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return IAIRoleMiningBetaApi;
		}(base_1.BaseAPI));
		exports.IAIRoleMiningBetaApi = IAIRoleMiningBetaApi;
		/**
		 * IdentitiesBetaApi - axios parameter creator
		 * @export
		 */
		var IdentitiesBetaApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * The API returns successful response if the requested identity was deleted.
		         * @summary Deletes an identity.
		         * @param {string} id Identity Id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteIdentity: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('deleteIdentity', 'id', id);
		                            localVarPath = "/identities/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'DELETE' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns a single identity using the Identity ID.
		         * @summary Identity Details
		         * @param {string} id Identity Id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getIdentity: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getIdentity', 'id', id);
		                            localVarPath = "/identities/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Get Ownership association details of an Identity
		         * @summary Get ownership details
		         * @param {string} identityId The identity id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getIdentityOwnershipDetails: function (identityId, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'identityId' is not null or undefined
		                            (0, common_1.assertParamExists)('getIdentityOwnershipDetails', 'identityId', identityId);
		                            localVarPath = "/identities/{identityId}/ownership"
		                                .replace("{".concat("identityId", "}"), encodeURIComponent(String(identityId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns a list of identities.
		         * @summary List Identities
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **name**: *eq, sw*  **alias**: *eq, sw*  **firstname**: *eq, sw*  **lastname**: *eq, sw*  **email**: *eq, sw*  **cloudStatus**: *eq*  **processingState**: *eq*  **correlated**: *eq*  **protected**: *eq*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name, alias, cloudStatus**
		         * @param {'CORRELATED_ONLY' | 'NONE'} [defaultFilter] Adds additional filter to filters query parameter.  CORRELATED_ONLY adds correlated&#x3D;true and returns only identities that are correlated.  NONE does not add any and returns all identities that satisfy filters query parameter.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listIdentities: function (filters, sorters, defaultFilter, count, limit, offset, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/identities";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            if (defaultFilter !== undefined) {
		                                localVarQueryParameter['defaultFilter'] = defaultFilter;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * You could use this endpoint to: 1. Calculate identity attributes, including applying or running any rules or transforms (e.g. calculate Lifecycle State at a point-in-time it\'s expected to change). 2. Evaluate role assignments, leading to assignment of new roles and removal of existing roles. 3. Enforce provisioning for any assigned accesses that haven\'t been fulfilled (e.g. failure due to source health). 4. Recalculate manager relationships. 5. Potentially clean-up identity processing errors, assuming the error has been resolved.  To learn more, refer to the [identity processing documentation](https://documentation.sailpoint.com/saas/help/setup/identity_processing.html).  A token with ORG_ADMIN or HELPDESK authority is required to call this API.
		         * @summary Process a list of identityIds
		         * @param {ProcessIdentitiesRequestBeta} processIdentitiesRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        startIdentityProcessing: function (processIdentitiesRequestBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'processIdentitiesRequestBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('startIdentityProcessing', 'processIdentitiesRequestBeta', processIdentitiesRequestBeta);
		                            localVarPath = "/identities/process";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(processIdentitiesRequestBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This end-point performs attribute synchronization for a selected identity. The endpoint can be called once in 10 seconds per identity. A token with ORG_ADMIN or API authority is required to call this API.
		         * @summary Attribute synchronization for single identity.
		         * @param {string} identityId The Identity id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        synchronizeAttributesForIdentity: function (identityId, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'identityId' is not null or undefined
		                            (0, common_1.assertParamExists)('synchronizeAttributesForIdentity', 'identityId', identityId);
		                            localVarPath = "/identities/{identityId}/synchronize-attributes"
		                                .replace("{".concat("identityId", "}"), encodeURIComponent(String(identityId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.IdentitiesBetaApiAxiosParamCreator = IdentitiesBetaApiAxiosParamCreator;
		/**
		 * IdentitiesBetaApi - functional programming interface
		 * @export
		 */
		var IdentitiesBetaApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.IdentitiesBetaApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * The API returns successful response if the requested identity was deleted.
		         * @summary Deletes an identity.
		         * @param {string} id Identity Id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteIdentity: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.deleteIdentity(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns a single identity using the Identity ID.
		         * @summary Identity Details
		         * @param {string} id Identity Id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getIdentity: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getIdentity(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Get Ownership association details of an Identity
		         * @summary Get ownership details
		         * @param {string} identityId The identity id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getIdentityOwnershipDetails: function (identityId, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getIdentityOwnershipDetails(identityId, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns a list of identities.
		         * @summary List Identities
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **name**: *eq, sw*  **alias**: *eq, sw*  **firstname**: *eq, sw*  **lastname**: *eq, sw*  **email**: *eq, sw*  **cloudStatus**: *eq*  **processingState**: *eq*  **correlated**: *eq*  **protected**: *eq*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name, alias, cloudStatus**
		         * @param {'CORRELATED_ONLY' | 'NONE'} [defaultFilter] Adds additional filter to filters query parameter.  CORRELATED_ONLY adds correlated&#x3D;true and returns only identities that are correlated.  NONE does not add any and returns all identities that satisfy filters query parameter.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listIdentities: function (filters, sorters, defaultFilter, count, limit, offset, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listIdentities(filters, sorters, defaultFilter, count, limit, offset, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * You could use this endpoint to: 1. Calculate identity attributes, including applying or running any rules or transforms (e.g. calculate Lifecycle State at a point-in-time it\'s expected to change). 2. Evaluate role assignments, leading to assignment of new roles and removal of existing roles. 3. Enforce provisioning for any assigned accesses that haven\'t been fulfilled (e.g. failure due to source health). 4. Recalculate manager relationships. 5. Potentially clean-up identity processing errors, assuming the error has been resolved.  To learn more, refer to the [identity processing documentation](https://documentation.sailpoint.com/saas/help/setup/identity_processing.html).  A token with ORG_ADMIN or HELPDESK authority is required to call this API.
		         * @summary Process a list of identityIds
		         * @param {ProcessIdentitiesRequestBeta} processIdentitiesRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        startIdentityProcessing: function (processIdentitiesRequestBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.startIdentityProcessing(processIdentitiesRequestBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This end-point performs attribute synchronization for a selected identity. The endpoint can be called once in 10 seconds per identity. A token with ORG_ADMIN or API authority is required to call this API.
		         * @summary Attribute synchronization for single identity.
		         * @param {string} identityId The Identity id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        synchronizeAttributesForIdentity: function (identityId, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.synchronizeAttributesForIdentity(identityId, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.IdentitiesBetaApiFp = IdentitiesBetaApiFp;
		/**
		 * IdentitiesBetaApi - factory interface
		 * @export
		 */
		var IdentitiesBetaApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.IdentitiesBetaApiFp)(configuration);
		    return {
		        /**
		         * The API returns successful response if the requested identity was deleted.
		         * @summary Deletes an identity.
		         * @param {string} id Identity Id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteIdentity: function (id, axiosOptions) {
		            return localVarFp.deleteIdentity(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API returns a single identity using the Identity ID.
		         * @summary Identity Details
		         * @param {string} id Identity Id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getIdentity: function (id, axiosOptions) {
		            return localVarFp.getIdentity(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Get Ownership association details of an Identity
		         * @summary Get ownership details
		         * @param {string} identityId The identity id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getIdentityOwnershipDetails: function (identityId, axiosOptions) {
		            return localVarFp.getIdentityOwnershipDetails(identityId, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API returns a list of identities.
		         * @summary List Identities
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **name**: *eq, sw*  **alias**: *eq, sw*  **firstname**: *eq, sw*  **lastname**: *eq, sw*  **email**: *eq, sw*  **cloudStatus**: *eq*  **processingState**: *eq*  **correlated**: *eq*  **protected**: *eq*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name, alias, cloudStatus**
		         * @param {'CORRELATED_ONLY' | 'NONE'} [defaultFilter] Adds additional filter to filters query parameter.  CORRELATED_ONLY adds correlated&#x3D;true and returns only identities that are correlated.  NONE does not add any and returns all identities that satisfy filters query parameter.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listIdentities: function (filters, sorters, defaultFilter, count, limit, offset, axiosOptions) {
		            return localVarFp.listIdentities(filters, sorters, defaultFilter, count, limit, offset, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * You could use this endpoint to: 1. Calculate identity attributes, including applying or running any rules or transforms (e.g. calculate Lifecycle State at a point-in-time it\'s expected to change). 2. Evaluate role assignments, leading to assignment of new roles and removal of existing roles. 3. Enforce provisioning for any assigned accesses that haven\'t been fulfilled (e.g. failure due to source health). 4. Recalculate manager relationships. 5. Potentially clean-up identity processing errors, assuming the error has been resolved.  To learn more, refer to the [identity processing documentation](https://documentation.sailpoint.com/saas/help/setup/identity_processing.html).  A token with ORG_ADMIN or HELPDESK authority is required to call this API.
		         * @summary Process a list of identityIds
		         * @param {ProcessIdentitiesRequestBeta} processIdentitiesRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        startIdentityProcessing: function (processIdentitiesRequestBeta, axiosOptions) {
		            return localVarFp.startIdentityProcessing(processIdentitiesRequestBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This end-point performs attribute synchronization for a selected identity. The endpoint can be called once in 10 seconds per identity. A token with ORG_ADMIN or API authority is required to call this API.
		         * @summary Attribute synchronization for single identity.
		         * @param {string} identityId The Identity id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        synchronizeAttributesForIdentity: function (identityId, axiosOptions) {
		            return localVarFp.synchronizeAttributesForIdentity(identityId, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.IdentitiesBetaApiFactory = IdentitiesBetaApiFactory;
		/**
		 * IdentitiesBetaApi - object-oriented interface
		 * @export
		 * @class IdentitiesBetaApi
		 * @extends {BaseAPI}
		 */
		var IdentitiesBetaApi = /** @class */ (function (_super) {
		    __extends(IdentitiesBetaApi, _super);
		    function IdentitiesBetaApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * The API returns successful response if the requested identity was deleted.
		     * @summary Deletes an identity.
		     * @param {IdentitiesBetaApiDeleteIdentityRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IdentitiesBetaApi
		     */
		    IdentitiesBetaApi.prototype.deleteIdentity = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.IdentitiesBetaApiFp)(this.configuration).deleteIdentity(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API returns a single identity using the Identity ID.
		     * @summary Identity Details
		     * @param {IdentitiesBetaApiGetIdentityRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IdentitiesBetaApi
		     */
		    IdentitiesBetaApi.prototype.getIdentity = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.IdentitiesBetaApiFp)(this.configuration).getIdentity(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Get Ownership association details of an Identity
		     * @summary Get ownership details
		     * @param {IdentitiesBetaApiGetIdentityOwnershipDetailsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IdentitiesBetaApi
		     */
		    IdentitiesBetaApi.prototype.getIdentityOwnershipDetails = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.IdentitiesBetaApiFp)(this.configuration).getIdentityOwnershipDetails(requestParameters.identityId, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API returns a list of identities.
		     * @summary List Identities
		     * @param {IdentitiesBetaApiListIdentitiesRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IdentitiesBetaApi
		     */
		    IdentitiesBetaApi.prototype.listIdentities = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.IdentitiesBetaApiFp)(this.configuration).listIdentities(requestParameters.filters, requestParameters.sorters, requestParameters.defaultFilter, requestParameters.count, requestParameters.limit, requestParameters.offset, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * You could use this endpoint to: 1. Calculate identity attributes, including applying or running any rules or transforms (e.g. calculate Lifecycle State at a point-in-time it\'s expected to change). 2. Evaluate role assignments, leading to assignment of new roles and removal of existing roles. 3. Enforce provisioning for any assigned accesses that haven\'t been fulfilled (e.g. failure due to source health). 4. Recalculate manager relationships. 5. Potentially clean-up identity processing errors, assuming the error has been resolved.  To learn more, refer to the [identity processing documentation](https://documentation.sailpoint.com/saas/help/setup/identity_processing.html).  A token with ORG_ADMIN or HELPDESK authority is required to call this API.
		     * @summary Process a list of identityIds
		     * @param {IdentitiesBetaApiStartIdentityProcessingRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IdentitiesBetaApi
		     */
		    IdentitiesBetaApi.prototype.startIdentityProcessing = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.IdentitiesBetaApiFp)(this.configuration).startIdentityProcessing(requestParameters.processIdentitiesRequestBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This end-point performs attribute synchronization for a selected identity. The endpoint can be called once in 10 seconds per identity. A token with ORG_ADMIN or API authority is required to call this API.
		     * @summary Attribute synchronization for single identity.
		     * @param {IdentitiesBetaApiSynchronizeAttributesForIdentityRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IdentitiesBetaApi
		     */
		    IdentitiesBetaApi.prototype.synchronizeAttributesForIdentity = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.IdentitiesBetaApiFp)(this.configuration).synchronizeAttributesForIdentity(requestParameters.identityId, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return IdentitiesBetaApi;
		}(base_1.BaseAPI));
		exports.IdentitiesBetaApi = IdentitiesBetaApi;
		/**
		 * IdentityAttributesBetaApi - axios parameter creator
		 * @export
		 */
		var IdentityAttributesBetaApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * This creates a new identity attribute.
		         * @summary Create Identity Attribute
		         * @param {IdentityAttributeBeta} identityAttributeBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createIdentityAttribute: function (identityAttributeBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'identityAttributeBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('createIdentityAttribute', 'identityAttributeBeta', identityAttributeBeta);
		                            localVarPath = "/identity-attributes";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(identityAttributeBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This deletes an identity attribute with the given name.  The `system` and `standard` properties must be set to false before you can delete an identity attribute.
		         * @summary Delete Identity Attribute
		         * @param {string} name The attribute\&#39;s technical name.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteIdentityAttribute: function (name, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'name' is not null or undefined
		                            (0, common_1.assertParamExists)('deleteIdentityAttribute', 'name', name);
		                            localVarPath = "/identity-attributes/{name}"
		                                .replace("{".concat("name", "}"), encodeURIComponent(String(name)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'DELETE' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This deletes identity attributes for a given set of names. Attributes that are currently mapped in an Identity Profile cannot be deleted.  The `system` and `standard` properties must be set to false before you can delete an identity attribute.
		         * @summary Bulk delete Identity Attributes
		         * @param {IdentityAttributeNamesBeta} identityAttributeNamesBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteIdentityAttributesInBulk: function (identityAttributeNamesBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'identityAttributeNamesBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('deleteIdentityAttributesInBulk', 'identityAttributeNamesBeta', identityAttributeNamesBeta);
		                            localVarPath = "/identity-attributes/bulk-delete";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(identityAttributeNamesBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets an identity attribute for a given technical name.
		         * @summary Get Identity Attribute
		         * @param {string} name The attribute\&#39;s technical name.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getIdentityAttribute: function (name, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'name' is not null or undefined
		                            (0, common_1.assertParamExists)('getIdentityAttribute', 'name', name);
		                            localVarPath = "/identity-attributes/{name}"
		                                .replace("{".concat("name", "}"), encodeURIComponent(String(name)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets a collection of identity attributes.
		         * @summary List Identity Attributes
		         * @param {boolean} [includeSystem] Include \&quot;system\&quot; attributes in the response.
		         * @param {boolean} [includeSilent] Include \&quot;silent\&quot; attributes in the response.
		         * @param {boolean} [searchableOnly] Include only \&quot;searchable\&quot; attributes in the response.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listIdentityAttributes: function (includeSystem, includeSilent, searchableOnly, count, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/identity-attributes";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (includeSystem !== undefined) {
		                                localVarQueryParameter['includeSystem'] = includeSystem;
		                            }
		                            if (includeSilent !== undefined) {
		                                localVarQueryParameter['includeSilent'] = includeSilent;
		                            }
		                            if (searchableOnly !== undefined) {
		                                localVarQueryParameter['searchableOnly'] = searchableOnly;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This updates an existing identity attribute.  Making an attribute searchable requires that the `system`, `standard`, and `multi` properties be set to false.
		         * @summary Update Identity Attribute
		         * @param {string} name The attribute\&#39;s technical name.
		         * @param {IdentityAttributeBeta} identityAttributeBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putIdentityAttribute: function (name, identityAttributeBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'name' is not null or undefined
		                            (0, common_1.assertParamExists)('putIdentityAttribute', 'name', name);
		                            // verify required parameter 'identityAttributeBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('putIdentityAttribute', 'identityAttributeBeta', identityAttributeBeta);
		                            localVarPath = "/identity-attributes/{name}"
		                                .replace("{".concat("name", "}"), encodeURIComponent(String(name)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PUT' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(identityAttributeBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.IdentityAttributesBetaApiAxiosParamCreator = IdentityAttributesBetaApiAxiosParamCreator;
		/**
		 * IdentityAttributesBetaApi - functional programming interface
		 * @export
		 */
		var IdentityAttributesBetaApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.IdentityAttributesBetaApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * This creates a new identity attribute.
		         * @summary Create Identity Attribute
		         * @param {IdentityAttributeBeta} identityAttributeBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createIdentityAttribute: function (identityAttributeBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.createIdentityAttribute(identityAttributeBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This deletes an identity attribute with the given name.  The `system` and `standard` properties must be set to false before you can delete an identity attribute.
		         * @summary Delete Identity Attribute
		         * @param {string} name The attribute\&#39;s technical name.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteIdentityAttribute: function (name, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.deleteIdentityAttribute(name, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This deletes identity attributes for a given set of names. Attributes that are currently mapped in an Identity Profile cannot be deleted.  The `system` and `standard` properties must be set to false before you can delete an identity attribute.
		         * @summary Bulk delete Identity Attributes
		         * @param {IdentityAttributeNamesBeta} identityAttributeNamesBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteIdentityAttributesInBulk: function (identityAttributeNamesBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.deleteIdentityAttributesInBulk(identityAttributeNamesBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets an identity attribute for a given technical name.
		         * @summary Get Identity Attribute
		         * @param {string} name The attribute\&#39;s technical name.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getIdentityAttribute: function (name, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getIdentityAttribute(name, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets a collection of identity attributes.
		         * @summary List Identity Attributes
		         * @param {boolean} [includeSystem] Include \&quot;system\&quot; attributes in the response.
		         * @param {boolean} [includeSilent] Include \&quot;silent\&quot; attributes in the response.
		         * @param {boolean} [searchableOnly] Include only \&quot;searchable\&quot; attributes in the response.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listIdentityAttributes: function (includeSystem, includeSilent, searchableOnly, count, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listIdentityAttributes(includeSystem, includeSilent, searchableOnly, count, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This updates an existing identity attribute.  Making an attribute searchable requires that the `system`, `standard`, and `multi` properties be set to false.
		         * @summary Update Identity Attribute
		         * @param {string} name The attribute\&#39;s technical name.
		         * @param {IdentityAttributeBeta} identityAttributeBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putIdentityAttribute: function (name, identityAttributeBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.putIdentityAttribute(name, identityAttributeBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.IdentityAttributesBetaApiFp = IdentityAttributesBetaApiFp;
		/**
		 * IdentityAttributesBetaApi - factory interface
		 * @export
		 */
		var IdentityAttributesBetaApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.IdentityAttributesBetaApiFp)(configuration);
		    return {
		        /**
		         * This creates a new identity attribute.
		         * @summary Create Identity Attribute
		         * @param {IdentityAttributeBeta} identityAttributeBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createIdentityAttribute: function (identityAttributeBeta, axiosOptions) {
		            return localVarFp.createIdentityAttribute(identityAttributeBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This deletes an identity attribute with the given name.  The `system` and `standard` properties must be set to false before you can delete an identity attribute.
		         * @summary Delete Identity Attribute
		         * @param {string} name The attribute\&#39;s technical name.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteIdentityAttribute: function (name, axiosOptions) {
		            return localVarFp.deleteIdentityAttribute(name, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This deletes identity attributes for a given set of names. Attributes that are currently mapped in an Identity Profile cannot be deleted.  The `system` and `standard` properties must be set to false before you can delete an identity attribute.
		         * @summary Bulk delete Identity Attributes
		         * @param {IdentityAttributeNamesBeta} identityAttributeNamesBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteIdentityAttributesInBulk: function (identityAttributeNamesBeta, axiosOptions) {
		            return localVarFp.deleteIdentityAttributesInBulk(identityAttributeNamesBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This gets an identity attribute for a given technical name.
		         * @summary Get Identity Attribute
		         * @param {string} name The attribute\&#39;s technical name.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getIdentityAttribute: function (name, axiosOptions) {
		            return localVarFp.getIdentityAttribute(name, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This gets a collection of identity attributes.
		         * @summary List Identity Attributes
		         * @param {boolean} [includeSystem] Include \&quot;system\&quot; attributes in the response.
		         * @param {boolean} [includeSilent] Include \&quot;silent\&quot; attributes in the response.
		         * @param {boolean} [searchableOnly] Include only \&quot;searchable\&quot; attributes in the response.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listIdentityAttributes: function (includeSystem, includeSilent, searchableOnly, count, axiosOptions) {
		            return localVarFp.listIdentityAttributes(includeSystem, includeSilent, searchableOnly, count, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This updates an existing identity attribute.  Making an attribute searchable requires that the `system`, `standard`, and `multi` properties be set to false.
		         * @summary Update Identity Attribute
		         * @param {string} name The attribute\&#39;s technical name.
		         * @param {IdentityAttributeBeta} identityAttributeBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putIdentityAttribute: function (name, identityAttributeBeta, axiosOptions) {
		            return localVarFp.putIdentityAttribute(name, identityAttributeBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.IdentityAttributesBetaApiFactory = IdentityAttributesBetaApiFactory;
		/**
		 * IdentityAttributesBetaApi - object-oriented interface
		 * @export
		 * @class IdentityAttributesBetaApi
		 * @extends {BaseAPI}
		 */
		var IdentityAttributesBetaApi = /** @class */ (function (_super) {
		    __extends(IdentityAttributesBetaApi, _super);
		    function IdentityAttributesBetaApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * This creates a new identity attribute.
		     * @summary Create Identity Attribute
		     * @param {IdentityAttributesBetaApiCreateIdentityAttributeRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IdentityAttributesBetaApi
		     */
		    IdentityAttributesBetaApi.prototype.createIdentityAttribute = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.IdentityAttributesBetaApiFp)(this.configuration).createIdentityAttribute(requestParameters.identityAttributeBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This deletes an identity attribute with the given name.  The `system` and `standard` properties must be set to false before you can delete an identity attribute.
		     * @summary Delete Identity Attribute
		     * @param {IdentityAttributesBetaApiDeleteIdentityAttributeRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IdentityAttributesBetaApi
		     */
		    IdentityAttributesBetaApi.prototype.deleteIdentityAttribute = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.IdentityAttributesBetaApiFp)(this.configuration).deleteIdentityAttribute(requestParameters.name, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This deletes identity attributes for a given set of names. Attributes that are currently mapped in an Identity Profile cannot be deleted.  The `system` and `standard` properties must be set to false before you can delete an identity attribute.
		     * @summary Bulk delete Identity Attributes
		     * @param {IdentityAttributesBetaApiDeleteIdentityAttributesInBulkRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IdentityAttributesBetaApi
		     */
		    IdentityAttributesBetaApi.prototype.deleteIdentityAttributesInBulk = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.IdentityAttributesBetaApiFp)(this.configuration).deleteIdentityAttributesInBulk(requestParameters.identityAttributeNamesBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This gets an identity attribute for a given technical name.
		     * @summary Get Identity Attribute
		     * @param {IdentityAttributesBetaApiGetIdentityAttributeRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IdentityAttributesBetaApi
		     */
		    IdentityAttributesBetaApi.prototype.getIdentityAttribute = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.IdentityAttributesBetaApiFp)(this.configuration).getIdentityAttribute(requestParameters.name, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This gets a collection of identity attributes.
		     * @summary List Identity Attributes
		     * @param {IdentityAttributesBetaApiListIdentityAttributesRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IdentityAttributesBetaApi
		     */
		    IdentityAttributesBetaApi.prototype.listIdentityAttributes = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.IdentityAttributesBetaApiFp)(this.configuration).listIdentityAttributes(requestParameters.includeSystem, requestParameters.includeSilent, requestParameters.searchableOnly, requestParameters.count, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This updates an existing identity attribute.  Making an attribute searchable requires that the `system`, `standard`, and `multi` properties be set to false.
		     * @summary Update Identity Attribute
		     * @param {IdentityAttributesBetaApiPutIdentityAttributeRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IdentityAttributesBetaApi
		     */
		    IdentityAttributesBetaApi.prototype.putIdentityAttribute = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.IdentityAttributesBetaApiFp)(this.configuration).putIdentityAttribute(requestParameters.name, requestParameters.identityAttributeBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return IdentityAttributesBetaApi;
		}(base_1.BaseAPI));
		exports.IdentityAttributesBetaApi = IdentityAttributesBetaApi;
		/**
		 * IdentityHistoryBetaApi - axios parameter creator
		 * @export
		 */
		var IdentityHistoryBetaApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * This method gets a difference of count for each access item types for the given identity between 2 snapshots Requires authorization scope of \'idn:identity-history:read\'
		         * @summary Gets a difference of count for each access item types for the given identity between 2 snapshots
		         * @param {string} id The identity id
		         * @param {string} [snapshot1] The snapshot 1 of identity
		         * @param {string} [snapshot2] The snapshot 2 of identity
		         * @param {Array<string>} [accessItemTypes] An optional list of access item types (app, account, entitlement, etc...) to return.   If null or empty, all access items types are returned
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        compareIdentitySnapshots: function (id, snapshot1, snapshot2, accessItemTypes, limit, offset, count, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('compareIdentitySnapshots', 'id', id);
		                            localVarPath = "/historical-identities/{id}/compare"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (snapshot1 !== undefined) {
		                                localVarQueryParameter['snapshot1'] = snapshot1;
		                            }
		                            if (snapshot2 !== undefined) {
		                                localVarQueryParameter['snapshot2'] = snapshot2;
		                            }
		                            if (accessItemTypes) {
		                                localVarQueryParameter['accessItemTypes'] = accessItemTypes.join(base_1.COLLECTION_FORMATS.csv);
		                            }
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This method gets a list of differences of specific accessType for the given identity between 2 snapshots Requires authorization scope of \'idn:identity-history:read\'
		         * @summary Gets a list of differences of specific accessType for the given identity between 2 snapshots
		         * @param {string} id The identity id
		         * @param {string} accessType The specific type which needs to be compared
		         * @param {boolean} [accessAssociated] Indicates if added or removed access needs to be returned. true - added, false - removed, null - both added &amp; removed
		         * @param {string} [snapshot1] The snapshot 1 of identity
		         * @param {string} [snapshot2] The snapshot 2 of identity
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        compareIdentitySnapshotsAccessType: function (id, accessType, accessAssociated, snapshot1, snapshot2, limit, offset, count, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('compareIdentitySnapshotsAccessType', 'id', id);
		                            // verify required parameter 'accessType' is not null or undefined
		                            (0, common_1.assertParamExists)('compareIdentitySnapshotsAccessType', 'accessType', accessType);
		                            localVarPath = "/historical-identities/{id}/compare/{access-type}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)))
		                                .replace("{".concat("accessType", "}"), encodeURIComponent(String(accessType)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (accessAssociated !== undefined) {
		                                localVarQueryParameter['access-associated'] = accessAssociated;
		                            }
		                            if (snapshot1 !== undefined) {
		                                localVarQueryParameter['snapshot1'] = snapshot1;
		                            }
		                            if (snapshot2 !== undefined) {
		                                localVarQueryParameter['snapshot2'] = snapshot2;
		                            }
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This method retrieves a specified identity Requires authorization scope of \'idn:identity-history:read\'
		         * @summary Get latest snapshot of identity
		         * @param {string} id The identity id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getHistoricalIdentity: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getHistoricalIdentity', 'id', id);
		                            localVarPath = "/historical-identities/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This method retrieves all access events for the identity Requires authorization scope of \'idn:identity-history:read\'
		         * @summary Lists all events for the given identity
		         * @param {string} id The identity id
		         * @param {string} [from] The optional instant from which to return the access events
		         * @param {Array<string>} [eventTypes] An optional list of event types to return.  If null or empty, all events are returned
		         * @param {Array<string>} [accessItemTypes] An optional list of access item types (app, account, entitlement, etc...) to return.   If null or empty, all access items types are returned
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getHistoricalIdentityEvents: function (id, from, eventTypes, accessItemTypes, limit, offset, count, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getHistoricalIdentityEvents', 'id', id);
		                            localVarPath = "/historical-identities/{id}/events"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (from !== undefined) {
		                                localVarQueryParameter['from'] = from;
		                            }
		                            if (eventTypes) {
		                                localVarQueryParameter['eventTypes'] = eventTypes.join(base_1.COLLECTION_FORMATS.csv);
		                            }
		                            if (accessItemTypes) {
		                                localVarQueryParameter['accessItemTypes'] = accessItemTypes.join(base_1.COLLECTION_FORMATS.csv);
		                            }
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This method retrieves a specified identity snapshot at a given date Requires authorization scope of \'idn:identity-history:read\'
		         * @summary Gets an identity snapshot at a given date
		         * @param {string} id The identity id
		         * @param {string} date The specified date
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getIdentitySnapshot: function (id, date, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getIdentitySnapshot', 'id', id);
		                            // verify required parameter 'date' is not null or undefined
		                            (0, common_1.assertParamExists)('getIdentitySnapshot', 'date', date);
		                            localVarPath = "/historical-identities/{id}/snapshots/{date}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)))
		                                .replace("{".concat("date", "}"), encodeURIComponent(String(date)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This method gets the summary for the event count for a specific identity by month/day Requires authorization scope of \'idn:identity-history:read\'
		         * @summary Gets the summary for the event count for a specific identity
		         * @param {string} id The identity id
		         * @param {string} [before] The date before which snapshot summary is required
		         * @param {'day' | 'month'} [interval] The interval indicating day or month. Defaults to month if not specified
		         * @param {string} [timeZone] The time zone. Defaults to UTC if not provided
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getIdentitySnapshotSummary: function (id, before, interval, timeZone, limit, offset, count, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getIdentitySnapshotSummary', 'id', id);
		                            localVarPath = "/historical-identities/{id}/snapshot-summary"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (before !== undefined) {
		                                localVarQueryParameter['before'] = before;
		                            }
		                            if (interval !== undefined) {
		                                localVarQueryParameter['interval'] = interval;
		                            }
		                            if (timeZone !== undefined) {
		                                localVarQueryParameter['time-zone'] = timeZone;
		                            }
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This method retrieves start date of the identity Requires authorization scope of \'idn:identity-history:read\'
		         * @summary Gets the start date of the identity
		         * @param {string} id The identity id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getIdentityStartDate: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getIdentityStartDate', 'id', id);
		                            localVarPath = "/historical-identities/{id}/start-date"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets the list of identities for the customer. This list end point does not support count=true request param. The total  count of identities would never be returned even if the count param is specified in the request Requires authorization scope of \'idn:identity-history:read\'
		         * @summary Lists all the identities
		         * @param {string} [startsWithQuery] This param is used for starts-with search for first, last and display name of the identity
		         * @param {boolean} [isDeleted] Indicates if we want to only list down deleted identities or not.
		         * @param {boolean} [isActive] Indicates if we want to only list active or inactive identities.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listHistoricalIdentities: function (startsWithQuery, isDeleted, isActive, limit, offset, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/historical-identities";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (startsWithQuery !== undefined) {
		                                localVarQueryParameter['starts-with-query'] = startsWithQuery;
		                            }
		                            if (isDeleted !== undefined) {
		                                localVarQueryParameter['is-deleted'] = isDeleted;
		                            }
		                            if (isActive !== undefined) {
		                                localVarQueryParameter['is-active'] = isActive;
		                            }
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This method retrieves a list of access item for the identity filtered by the access item type Requires authorization scope of \'idn:identity-history:read\'
		         * @summary Gets a list of access items for the identity filtered by item type
		         * @param {string} id The identity id
		         * @param {string} [type] The type of access item for the identity. If not provided, it defaults to account
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listIdentityAccessItems: function (id, type, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('listIdentityAccessItems', 'id', id);
		                            localVarPath = "/historical-identities/{id}/access-items"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (type !== undefined) {
		                                localVarQueryParameter['type'] = type;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This method retrieves the list of identity access items at a given date filterd by item type Requires authorization scope of \'idn:identity-history:read\'
		         * @summary Gets the list of identity access items at a given date filterd by item type
		         * @param {string} id The identity id
		         * @param {string} date The specified date
		         * @param {string} [type] The access item type
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listIdentitySnapshotAccessItems: function (id, date, type, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('listIdentitySnapshotAccessItems', 'id', id);
		                            // verify required parameter 'date' is not null or undefined
		                            (0, common_1.assertParamExists)('listIdentitySnapshotAccessItems', 'date', date);
		                            localVarPath = "/historical-identities/{id}/snapshots/{date}/access-items"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)))
		                                .replace("{".concat("date", "}"), encodeURIComponent(String(date)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (type !== undefined) {
		                                localVarQueryParameter['type'] = type;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This method retrieves all the snapshots for the identity Requires authorization scope of \'idn:identity-history:read\'
		         * @summary Lists all the snapshots for the identity
		         * @param {string} id The identity id
		         * @param {string} [start] The specified start date
		         * @param {'day' | 'month'} [interval] The interval indicating the range in day or month for the specified interval-name
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listIdentitySnapshots: function (id, start, interval, limit, offset, count, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('listIdentitySnapshots', 'id', id);
		                            localVarPath = "/historical-identities/{id}/snapshots"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (start !== undefined) {
		                                localVarQueryParameter['start'] = start;
		                            }
		                            if (interval !== undefined) {
		                                localVarQueryParameter['interval'] = interval;
		                            }
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.IdentityHistoryBetaApiAxiosParamCreator = IdentityHistoryBetaApiAxiosParamCreator;
		/**
		 * IdentityHistoryBetaApi - functional programming interface
		 * @export
		 */
		var IdentityHistoryBetaApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.IdentityHistoryBetaApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * This method gets a difference of count for each access item types for the given identity between 2 snapshots Requires authorization scope of \'idn:identity-history:read\'
		         * @summary Gets a difference of count for each access item types for the given identity between 2 snapshots
		         * @param {string} id The identity id
		         * @param {string} [snapshot1] The snapshot 1 of identity
		         * @param {string} [snapshot2] The snapshot 2 of identity
		         * @param {Array<string>} [accessItemTypes] An optional list of access item types (app, account, entitlement, etc...) to return.   If null or empty, all access items types are returned
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        compareIdentitySnapshots: function (id, snapshot1, snapshot2, accessItemTypes, limit, offset, count, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.compareIdentitySnapshots(id, snapshot1, snapshot2, accessItemTypes, limit, offset, count, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This method gets a list of differences of specific accessType for the given identity between 2 snapshots Requires authorization scope of \'idn:identity-history:read\'
		         * @summary Gets a list of differences of specific accessType for the given identity between 2 snapshots
		         * @param {string} id The identity id
		         * @param {string} accessType The specific type which needs to be compared
		         * @param {boolean} [accessAssociated] Indicates if added or removed access needs to be returned. true - added, false - removed, null - both added &amp; removed
		         * @param {string} [snapshot1] The snapshot 1 of identity
		         * @param {string} [snapshot2] The snapshot 2 of identity
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        compareIdentitySnapshotsAccessType: function (id, accessType, accessAssociated, snapshot1, snapshot2, limit, offset, count, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.compareIdentitySnapshotsAccessType(id, accessType, accessAssociated, snapshot1, snapshot2, limit, offset, count, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This method retrieves a specified identity Requires authorization scope of \'idn:identity-history:read\'
		         * @summary Get latest snapshot of identity
		         * @param {string} id The identity id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getHistoricalIdentity: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getHistoricalIdentity(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This method retrieves all access events for the identity Requires authorization scope of \'idn:identity-history:read\'
		         * @summary Lists all events for the given identity
		         * @param {string} id The identity id
		         * @param {string} [from] The optional instant from which to return the access events
		         * @param {Array<string>} [eventTypes] An optional list of event types to return.  If null or empty, all events are returned
		         * @param {Array<string>} [accessItemTypes] An optional list of access item types (app, account, entitlement, etc...) to return.   If null or empty, all access items types are returned
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getHistoricalIdentityEvents: function (id, from, eventTypes, accessItemTypes, limit, offset, count, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getHistoricalIdentityEvents(id, from, eventTypes, accessItemTypes, limit, offset, count, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This method retrieves a specified identity snapshot at a given date Requires authorization scope of \'idn:identity-history:read\'
		         * @summary Gets an identity snapshot at a given date
		         * @param {string} id The identity id
		         * @param {string} date The specified date
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getIdentitySnapshot: function (id, date, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getIdentitySnapshot(id, date, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This method gets the summary for the event count for a specific identity by month/day Requires authorization scope of \'idn:identity-history:read\'
		         * @summary Gets the summary for the event count for a specific identity
		         * @param {string} id The identity id
		         * @param {string} [before] The date before which snapshot summary is required
		         * @param {'day' | 'month'} [interval] The interval indicating day or month. Defaults to month if not specified
		         * @param {string} [timeZone] The time zone. Defaults to UTC if not provided
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getIdentitySnapshotSummary: function (id, before, interval, timeZone, limit, offset, count, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getIdentitySnapshotSummary(id, before, interval, timeZone, limit, offset, count, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This method retrieves start date of the identity Requires authorization scope of \'idn:identity-history:read\'
		         * @summary Gets the start date of the identity
		         * @param {string} id The identity id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getIdentityStartDate: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getIdentityStartDate(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets the list of identities for the customer. This list end point does not support count=true request param. The total  count of identities would never be returned even if the count param is specified in the request Requires authorization scope of \'idn:identity-history:read\'
		         * @summary Lists all the identities
		         * @param {string} [startsWithQuery] This param is used for starts-with search for first, last and display name of the identity
		         * @param {boolean} [isDeleted] Indicates if we want to only list down deleted identities or not.
		         * @param {boolean} [isActive] Indicates if we want to only list active or inactive identities.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listHistoricalIdentities: function (startsWithQuery, isDeleted, isActive, limit, offset, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listHistoricalIdentities(startsWithQuery, isDeleted, isActive, limit, offset, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This method retrieves a list of access item for the identity filtered by the access item type Requires authorization scope of \'idn:identity-history:read\'
		         * @summary Gets a list of access items for the identity filtered by item type
		         * @param {string} id The identity id
		         * @param {string} [type] The type of access item for the identity. If not provided, it defaults to account
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listIdentityAccessItems: function (id, type, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listIdentityAccessItems(id, type, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This method retrieves the list of identity access items at a given date filterd by item type Requires authorization scope of \'idn:identity-history:read\'
		         * @summary Gets the list of identity access items at a given date filterd by item type
		         * @param {string} id The identity id
		         * @param {string} date The specified date
		         * @param {string} [type] The access item type
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listIdentitySnapshotAccessItems: function (id, date, type, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listIdentitySnapshotAccessItems(id, date, type, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This method retrieves all the snapshots for the identity Requires authorization scope of \'idn:identity-history:read\'
		         * @summary Lists all the snapshots for the identity
		         * @param {string} id The identity id
		         * @param {string} [start] The specified start date
		         * @param {'day' | 'month'} [interval] The interval indicating the range in day or month for the specified interval-name
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listIdentitySnapshots: function (id, start, interval, limit, offset, count, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listIdentitySnapshots(id, start, interval, limit, offset, count, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.IdentityHistoryBetaApiFp = IdentityHistoryBetaApiFp;
		/**
		 * IdentityHistoryBetaApi - factory interface
		 * @export
		 */
		var IdentityHistoryBetaApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.IdentityHistoryBetaApiFp)(configuration);
		    return {
		        /**
		         * This method gets a difference of count for each access item types for the given identity between 2 snapshots Requires authorization scope of \'idn:identity-history:read\'
		         * @summary Gets a difference of count for each access item types for the given identity between 2 snapshots
		         * @param {string} id The identity id
		         * @param {string} [snapshot1] The snapshot 1 of identity
		         * @param {string} [snapshot2] The snapshot 2 of identity
		         * @param {Array<string>} [accessItemTypes] An optional list of access item types (app, account, entitlement, etc...) to return.   If null or empty, all access items types are returned
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        compareIdentitySnapshots: function (id, snapshot1, snapshot2, accessItemTypes, limit, offset, count, axiosOptions) {
		            return localVarFp.compareIdentitySnapshots(id, snapshot1, snapshot2, accessItemTypes, limit, offset, count, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This method gets a list of differences of specific accessType for the given identity between 2 snapshots Requires authorization scope of \'idn:identity-history:read\'
		         * @summary Gets a list of differences of specific accessType for the given identity between 2 snapshots
		         * @param {string} id The identity id
		         * @param {string} accessType The specific type which needs to be compared
		         * @param {boolean} [accessAssociated] Indicates if added or removed access needs to be returned. true - added, false - removed, null - both added &amp; removed
		         * @param {string} [snapshot1] The snapshot 1 of identity
		         * @param {string} [snapshot2] The snapshot 2 of identity
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        compareIdentitySnapshotsAccessType: function (id, accessType, accessAssociated, snapshot1, snapshot2, limit, offset, count, axiosOptions) {
		            return localVarFp.compareIdentitySnapshotsAccessType(id, accessType, accessAssociated, snapshot1, snapshot2, limit, offset, count, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This method retrieves a specified identity Requires authorization scope of \'idn:identity-history:read\'
		         * @summary Get latest snapshot of identity
		         * @param {string} id The identity id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getHistoricalIdentity: function (id, axiosOptions) {
		            return localVarFp.getHistoricalIdentity(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This method retrieves all access events for the identity Requires authorization scope of \'idn:identity-history:read\'
		         * @summary Lists all events for the given identity
		         * @param {string} id The identity id
		         * @param {string} [from] The optional instant from which to return the access events
		         * @param {Array<string>} [eventTypes] An optional list of event types to return.  If null or empty, all events are returned
		         * @param {Array<string>} [accessItemTypes] An optional list of access item types (app, account, entitlement, etc...) to return.   If null or empty, all access items types are returned
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getHistoricalIdentityEvents: function (id, from, eventTypes, accessItemTypes, limit, offset, count, axiosOptions) {
		            return localVarFp.getHistoricalIdentityEvents(id, from, eventTypes, accessItemTypes, limit, offset, count, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This method retrieves a specified identity snapshot at a given date Requires authorization scope of \'idn:identity-history:read\'
		         * @summary Gets an identity snapshot at a given date
		         * @param {string} id The identity id
		         * @param {string} date The specified date
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getIdentitySnapshot: function (id, date, axiosOptions) {
		            return localVarFp.getIdentitySnapshot(id, date, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This method gets the summary for the event count for a specific identity by month/day Requires authorization scope of \'idn:identity-history:read\'
		         * @summary Gets the summary for the event count for a specific identity
		         * @param {string} id The identity id
		         * @param {string} [before] The date before which snapshot summary is required
		         * @param {'day' | 'month'} [interval] The interval indicating day or month. Defaults to month if not specified
		         * @param {string} [timeZone] The time zone. Defaults to UTC if not provided
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getIdentitySnapshotSummary: function (id, before, interval, timeZone, limit, offset, count, axiosOptions) {
		            return localVarFp.getIdentitySnapshotSummary(id, before, interval, timeZone, limit, offset, count, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This method retrieves start date of the identity Requires authorization scope of \'idn:identity-history:read\'
		         * @summary Gets the start date of the identity
		         * @param {string} id The identity id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getIdentityStartDate: function (id, axiosOptions) {
		            return localVarFp.getIdentityStartDate(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This gets the list of identities for the customer. This list end point does not support count=true request param. The total  count of identities would never be returned even if the count param is specified in the request Requires authorization scope of \'idn:identity-history:read\'
		         * @summary Lists all the identities
		         * @param {string} [startsWithQuery] This param is used for starts-with search for first, last and display name of the identity
		         * @param {boolean} [isDeleted] Indicates if we want to only list down deleted identities or not.
		         * @param {boolean} [isActive] Indicates if we want to only list active or inactive identities.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listHistoricalIdentities: function (startsWithQuery, isDeleted, isActive, limit, offset, axiosOptions) {
		            return localVarFp.listHistoricalIdentities(startsWithQuery, isDeleted, isActive, limit, offset, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This method retrieves a list of access item for the identity filtered by the access item type Requires authorization scope of \'idn:identity-history:read\'
		         * @summary Gets a list of access items for the identity filtered by item type
		         * @param {string} id The identity id
		         * @param {string} [type] The type of access item for the identity. If not provided, it defaults to account
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listIdentityAccessItems: function (id, type, axiosOptions) {
		            return localVarFp.listIdentityAccessItems(id, type, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This method retrieves the list of identity access items at a given date filterd by item type Requires authorization scope of \'idn:identity-history:read\'
		         * @summary Gets the list of identity access items at a given date filterd by item type
		         * @param {string} id The identity id
		         * @param {string} date The specified date
		         * @param {string} [type] The access item type
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listIdentitySnapshotAccessItems: function (id, date, type, axiosOptions) {
		            return localVarFp.listIdentitySnapshotAccessItems(id, date, type, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This method retrieves all the snapshots for the identity Requires authorization scope of \'idn:identity-history:read\'
		         * @summary Lists all the snapshots for the identity
		         * @param {string} id The identity id
		         * @param {string} [start] The specified start date
		         * @param {'day' | 'month'} [interval] The interval indicating the range in day or month for the specified interval-name
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listIdentitySnapshots: function (id, start, interval, limit, offset, count, axiosOptions) {
		            return localVarFp.listIdentitySnapshots(id, start, interval, limit, offset, count, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.IdentityHistoryBetaApiFactory = IdentityHistoryBetaApiFactory;
		/**
		 * IdentityHistoryBetaApi - object-oriented interface
		 * @export
		 * @class IdentityHistoryBetaApi
		 * @extends {BaseAPI}
		 */
		var IdentityHistoryBetaApi = /** @class */ (function (_super) {
		    __extends(IdentityHistoryBetaApi, _super);
		    function IdentityHistoryBetaApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * This method gets a difference of count for each access item types for the given identity between 2 snapshots Requires authorization scope of \'idn:identity-history:read\'
		     * @summary Gets a difference of count for each access item types for the given identity between 2 snapshots
		     * @param {IdentityHistoryBetaApiCompareIdentitySnapshotsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IdentityHistoryBetaApi
		     */
		    IdentityHistoryBetaApi.prototype.compareIdentitySnapshots = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.IdentityHistoryBetaApiFp)(this.configuration).compareIdentitySnapshots(requestParameters.id, requestParameters.snapshot1, requestParameters.snapshot2, requestParameters.accessItemTypes, requestParameters.limit, requestParameters.offset, requestParameters.count, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This method gets a list of differences of specific accessType for the given identity between 2 snapshots Requires authorization scope of \'idn:identity-history:read\'
		     * @summary Gets a list of differences of specific accessType for the given identity between 2 snapshots
		     * @param {IdentityHistoryBetaApiCompareIdentitySnapshotsAccessTypeRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IdentityHistoryBetaApi
		     */
		    IdentityHistoryBetaApi.prototype.compareIdentitySnapshotsAccessType = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.IdentityHistoryBetaApiFp)(this.configuration).compareIdentitySnapshotsAccessType(requestParameters.id, requestParameters.accessType, requestParameters.accessAssociated, requestParameters.snapshot1, requestParameters.snapshot2, requestParameters.limit, requestParameters.offset, requestParameters.count, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This method retrieves a specified identity Requires authorization scope of \'idn:identity-history:read\'
		     * @summary Get latest snapshot of identity
		     * @param {IdentityHistoryBetaApiGetHistoricalIdentityRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IdentityHistoryBetaApi
		     */
		    IdentityHistoryBetaApi.prototype.getHistoricalIdentity = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.IdentityHistoryBetaApiFp)(this.configuration).getHistoricalIdentity(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This method retrieves all access events for the identity Requires authorization scope of \'idn:identity-history:read\'
		     * @summary Lists all events for the given identity
		     * @param {IdentityHistoryBetaApiGetHistoricalIdentityEventsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IdentityHistoryBetaApi
		     */
		    IdentityHistoryBetaApi.prototype.getHistoricalIdentityEvents = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.IdentityHistoryBetaApiFp)(this.configuration).getHistoricalIdentityEvents(requestParameters.id, requestParameters.from, requestParameters.eventTypes, requestParameters.accessItemTypes, requestParameters.limit, requestParameters.offset, requestParameters.count, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This method retrieves a specified identity snapshot at a given date Requires authorization scope of \'idn:identity-history:read\'
		     * @summary Gets an identity snapshot at a given date
		     * @param {IdentityHistoryBetaApiGetIdentitySnapshotRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IdentityHistoryBetaApi
		     */
		    IdentityHistoryBetaApi.prototype.getIdentitySnapshot = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.IdentityHistoryBetaApiFp)(this.configuration).getIdentitySnapshot(requestParameters.id, requestParameters.date, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This method gets the summary for the event count for a specific identity by month/day Requires authorization scope of \'idn:identity-history:read\'
		     * @summary Gets the summary for the event count for a specific identity
		     * @param {IdentityHistoryBetaApiGetIdentitySnapshotSummaryRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IdentityHistoryBetaApi
		     */
		    IdentityHistoryBetaApi.prototype.getIdentitySnapshotSummary = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.IdentityHistoryBetaApiFp)(this.configuration).getIdentitySnapshotSummary(requestParameters.id, requestParameters.before, requestParameters.interval, requestParameters.timeZone, requestParameters.limit, requestParameters.offset, requestParameters.count, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This method retrieves start date of the identity Requires authorization scope of \'idn:identity-history:read\'
		     * @summary Gets the start date of the identity
		     * @param {IdentityHistoryBetaApiGetIdentityStartDateRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IdentityHistoryBetaApi
		     */
		    IdentityHistoryBetaApi.prototype.getIdentityStartDate = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.IdentityHistoryBetaApiFp)(this.configuration).getIdentityStartDate(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This gets the list of identities for the customer. This list end point does not support count=true request param. The total  count of identities would never be returned even if the count param is specified in the request Requires authorization scope of \'idn:identity-history:read\'
		     * @summary Lists all the identities
		     * @param {IdentityHistoryBetaApiListHistoricalIdentitiesRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IdentityHistoryBetaApi
		     */
		    IdentityHistoryBetaApi.prototype.listHistoricalIdentities = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.IdentityHistoryBetaApiFp)(this.configuration).listHistoricalIdentities(requestParameters.startsWithQuery, requestParameters.isDeleted, requestParameters.isActive, requestParameters.limit, requestParameters.offset, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This method retrieves a list of access item for the identity filtered by the access item type Requires authorization scope of \'idn:identity-history:read\'
		     * @summary Gets a list of access items for the identity filtered by item type
		     * @param {IdentityHistoryBetaApiListIdentityAccessItemsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IdentityHistoryBetaApi
		     */
		    IdentityHistoryBetaApi.prototype.listIdentityAccessItems = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.IdentityHistoryBetaApiFp)(this.configuration).listIdentityAccessItems(requestParameters.id, requestParameters.type, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This method retrieves the list of identity access items at a given date filterd by item type Requires authorization scope of \'idn:identity-history:read\'
		     * @summary Gets the list of identity access items at a given date filterd by item type
		     * @param {IdentityHistoryBetaApiListIdentitySnapshotAccessItemsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IdentityHistoryBetaApi
		     */
		    IdentityHistoryBetaApi.prototype.listIdentitySnapshotAccessItems = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.IdentityHistoryBetaApiFp)(this.configuration).listIdentitySnapshotAccessItems(requestParameters.id, requestParameters.date, requestParameters.type, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This method retrieves all the snapshots for the identity Requires authorization scope of \'idn:identity-history:read\'
		     * @summary Lists all the snapshots for the identity
		     * @param {IdentityHistoryBetaApiListIdentitySnapshotsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IdentityHistoryBetaApi
		     */
		    IdentityHistoryBetaApi.prototype.listIdentitySnapshots = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.IdentityHistoryBetaApiFp)(this.configuration).listIdentitySnapshots(requestParameters.id, requestParameters.start, requestParameters.interval, requestParameters.limit, requestParameters.offset, requestParameters.count, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return IdentityHistoryBetaApi;
		}(base_1.BaseAPI));
		exports.IdentityHistoryBetaApi = IdentityHistoryBetaApi;
		/**
		 * IdentityProfilesBetaApi - axios parameter creator
		 * @export
		 */
		var IdentityProfilesBetaApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * This creates an Identity Profile A token with ORG_ADMIN authority is required to call this API to create an Identity Profile.
		         * @summary Create an Identity Profile
		         * @param {IdentityProfileBeta} identityProfileBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createIdentityProfile: function (identityProfileBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'identityProfileBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('createIdentityProfile', 'identityProfileBeta', identityProfileBeta);
		                            localVarPath = "/identity-profiles";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(identityProfileBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This deletes an Identity Profile based on ID.  On success, this endpoint will return a reference to the bulk delete task result.  A token with ORG_ADMIN authority is required to call this API.  The following rights are required to access this endpoint: idn:identity-profile:delete
		         * @summary Delete an Identity Profile
		         * @param {string} identityProfileId The Identity Profile ID.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteIdentityProfile: function (identityProfileId, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'identityProfileId' is not null or undefined
		                            (0, common_1.assertParamExists)('deleteIdentityProfile', 'identityProfileId', identityProfileId);
		                            localVarPath = "/identity-profiles/{identity-profile-id}"
		                                .replace("{".concat("identity-profile-id", "}"), encodeURIComponent(String(identityProfileId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'DELETE' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This deletes multiple Identity Profiles via a list of supplied IDs.  On success, this endpoint will return a reference to the bulk delete task result.  A token with ORG_ADMIN authority is required to call this API.  The following rights are required to access this endpoint: idn:identity-profile:delete
		         * @summary Delete Identity Profiles
		         * @param {Array<string>} requestBody Identity Profile bulk delete request body.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteIdentityProfiles: function (requestBody, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'requestBody' is not null or undefined
		                            (0, common_1.assertParamExists)('deleteIdentityProfiles', 'requestBody', requestBody);
		                            localVarPath = "/identity-profiles/bulk-delete";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(requestBody, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This exports existing identity profiles in the format specified by the sp-config service.
		         * @summary Export Identity Profiles
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, ne*  **name**: *eq, ne*  **priority**: *eq, ne*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **id, name, priority**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        exportIdentityProfiles: function (limit, offset, count, filters, sorters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/identity-profiles/export";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This generates a non-persisted IdentityDetails object that will represent as the preview of the identities attribute when the given policy\'s attribute config is applied. A token with ORG_ADMIN authority is required to call this API to generate an identity preview.
		         * @summary Generate Identity Profile Preview
		         * @param {IdentityPreviewRequestBeta} identityPreviewRequestBeta Identity Preview request body.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        generateIdentityPreview: function (identityPreviewRequestBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'identityPreviewRequestBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('generateIdentityPreview', 'identityPreviewRequestBeta', identityPreviewRequestBeta);
		                            localVarPath = "/identity-profiles/identity-preview";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(identityPreviewRequestBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This returns the default identity attribute config A token with ORG_ADMIN authority is required to call this API to get the default identity attribute config.
		         * @summary Default identity attribute config
		         * @param {string} identityProfileId The Identity Profile ID
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getDefaultIdentityAttributeConfig: function (identityProfileId, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'identityProfileId' is not null or undefined
		                            (0, common_1.assertParamExists)('getDefaultIdentityAttributeConfig', 'identityProfileId', identityProfileId);
		                            localVarPath = "/identity-profiles/{identity-profile-id}/default-identity-attribute-config"
		                                .replace("{".concat("identity-profile-id", "}"), encodeURIComponent(String(identityProfileId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This returns a single Identity Profile based on ID. A token with ORG_ADMIN or API authority is required to call this API.
		         * @summary Gets a single Identity Profile
		         * @param {string} identityProfileId The Identity Profile ID
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getIdentityProfile: function (identityProfileId, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'identityProfileId' is not null or undefined
		                            (0, common_1.assertParamExists)('getIdentityProfile', 'identityProfileId', identityProfileId);
		                            localVarPath = "/identity-profiles/{identity-profile-id}"
		                                .replace("{".concat("identity-profile-id", "}"), encodeURIComponent(String(identityProfileId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This imports previously exported identity profiles.
		         * @summary Import Identity Profiles
		         * @param {Array<IdentityProfileExportedObjectBeta>} identityProfileExportedObjectBeta Previously exported Identity Profiles.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        importIdentityProfiles: function (identityProfileExportedObjectBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'identityProfileExportedObjectBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('importIdentityProfiles', 'identityProfileExportedObjectBeta', identityProfileExportedObjectBeta);
		                            localVarPath = "/identity-profiles/import";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(identityProfileExportedObjectBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This returns a list of Identity Profiles based on the specified query parameters. A token with ORG_ADMIN or API authority is required to call this API to get a list of Identity Profiles.
		         * @summary Identity Profiles list
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, ne, ge, gt, in, le, lt, isnull, sw*  **name**: *eq, ne, in, le, lt, isnull, sw*  **priority**: *eq, ne*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **id, name, priority, created, modified, owner.id, owner.name**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listIdentityProfiles: function (limit, offset, count, filters, sorters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/identity-profiles";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Process identities under the profile  A token with ORG_ADMIN authority is required to call this API.
		         * @summary Process identities under profile
		         * @param {string} identityProfileId The Identity Profile ID to be processed
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        syncIdentityProfile: function (identityProfileId, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'identityProfileId' is not null or undefined
		                            (0, common_1.assertParamExists)('syncIdentityProfile', 'identityProfileId', identityProfileId);
		                            localVarPath = "/identity-profiles/{identity-profile-id}/process-identities"
		                                .replace("{".concat("identity-profile-id", "}"), encodeURIComponent(String(identityProfileId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This updates the specified Identity Profile. A token with ORG_ADMIN authority is required to call this API to update the Identity Profile. Some fields of the Schema cannot be updated. These fields are listed below. * id * name * created * modified
		         * @summary Update the Identity Profile
		         * @param {string} identityProfileId The Identity Profile ID
		         * @param {Array<JsonPatchOperationBeta>} jsonPatchOperationBeta A list of Identity Profile update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateIdentityProfile: function (identityProfileId, jsonPatchOperationBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'identityProfileId' is not null or undefined
		                            (0, common_1.assertParamExists)('updateIdentityProfile', 'identityProfileId', identityProfileId);
		                            // verify required parameter 'jsonPatchOperationBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('updateIdentityProfile', 'jsonPatchOperationBeta', jsonPatchOperationBeta);
		                            localVarPath = "/identity-profiles/{identity-profile-id}"
		                                .replace("{".concat("identity-profile-id", "}"), encodeURIComponent(String(identityProfileId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PATCH' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json-patch+json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(jsonPatchOperationBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.IdentityProfilesBetaApiAxiosParamCreator = IdentityProfilesBetaApiAxiosParamCreator;
		/**
		 * IdentityProfilesBetaApi - functional programming interface
		 * @export
		 */
		var IdentityProfilesBetaApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.IdentityProfilesBetaApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * This creates an Identity Profile A token with ORG_ADMIN authority is required to call this API to create an Identity Profile.
		         * @summary Create an Identity Profile
		         * @param {IdentityProfileBeta} identityProfileBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createIdentityProfile: function (identityProfileBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.createIdentityProfile(identityProfileBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This deletes an Identity Profile based on ID.  On success, this endpoint will return a reference to the bulk delete task result.  A token with ORG_ADMIN authority is required to call this API.  The following rights are required to access this endpoint: idn:identity-profile:delete
		         * @summary Delete an Identity Profile
		         * @param {string} identityProfileId The Identity Profile ID.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteIdentityProfile: function (identityProfileId, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.deleteIdentityProfile(identityProfileId, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This deletes multiple Identity Profiles via a list of supplied IDs.  On success, this endpoint will return a reference to the bulk delete task result.  A token with ORG_ADMIN authority is required to call this API.  The following rights are required to access this endpoint: idn:identity-profile:delete
		         * @summary Delete Identity Profiles
		         * @param {Array<string>} requestBody Identity Profile bulk delete request body.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteIdentityProfiles: function (requestBody, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.deleteIdentityProfiles(requestBody, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This exports existing identity profiles in the format specified by the sp-config service.
		         * @summary Export Identity Profiles
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, ne*  **name**: *eq, ne*  **priority**: *eq, ne*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **id, name, priority**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        exportIdentityProfiles: function (limit, offset, count, filters, sorters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.exportIdentityProfiles(limit, offset, count, filters, sorters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This generates a non-persisted IdentityDetails object that will represent as the preview of the identities attribute when the given policy\'s attribute config is applied. A token with ORG_ADMIN authority is required to call this API to generate an identity preview.
		         * @summary Generate Identity Profile Preview
		         * @param {IdentityPreviewRequestBeta} identityPreviewRequestBeta Identity Preview request body.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        generateIdentityPreview: function (identityPreviewRequestBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.generateIdentityPreview(identityPreviewRequestBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This returns the default identity attribute config A token with ORG_ADMIN authority is required to call this API to get the default identity attribute config.
		         * @summary Default identity attribute config
		         * @param {string} identityProfileId The Identity Profile ID
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getDefaultIdentityAttributeConfig: function (identityProfileId, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getDefaultIdentityAttributeConfig(identityProfileId, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This returns a single Identity Profile based on ID. A token with ORG_ADMIN or API authority is required to call this API.
		         * @summary Gets a single Identity Profile
		         * @param {string} identityProfileId The Identity Profile ID
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getIdentityProfile: function (identityProfileId, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getIdentityProfile(identityProfileId, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This imports previously exported identity profiles.
		         * @summary Import Identity Profiles
		         * @param {Array<IdentityProfileExportedObjectBeta>} identityProfileExportedObjectBeta Previously exported Identity Profiles.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        importIdentityProfiles: function (identityProfileExportedObjectBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.importIdentityProfiles(identityProfileExportedObjectBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This returns a list of Identity Profiles based on the specified query parameters. A token with ORG_ADMIN or API authority is required to call this API to get a list of Identity Profiles.
		         * @summary Identity Profiles list
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, ne, ge, gt, in, le, lt, isnull, sw*  **name**: *eq, ne, in, le, lt, isnull, sw*  **priority**: *eq, ne*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **id, name, priority, created, modified, owner.id, owner.name**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listIdentityProfiles: function (limit, offset, count, filters, sorters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listIdentityProfiles(limit, offset, count, filters, sorters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Process identities under the profile  A token with ORG_ADMIN authority is required to call this API.
		         * @summary Process identities under profile
		         * @param {string} identityProfileId The Identity Profile ID to be processed
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        syncIdentityProfile: function (identityProfileId, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.syncIdentityProfile(identityProfileId, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This updates the specified Identity Profile. A token with ORG_ADMIN authority is required to call this API to update the Identity Profile. Some fields of the Schema cannot be updated. These fields are listed below. * id * name * created * modified
		         * @summary Update the Identity Profile
		         * @param {string} identityProfileId The Identity Profile ID
		         * @param {Array<JsonPatchOperationBeta>} jsonPatchOperationBeta A list of Identity Profile update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateIdentityProfile: function (identityProfileId, jsonPatchOperationBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.updateIdentityProfile(identityProfileId, jsonPatchOperationBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.IdentityProfilesBetaApiFp = IdentityProfilesBetaApiFp;
		/**
		 * IdentityProfilesBetaApi - factory interface
		 * @export
		 */
		var IdentityProfilesBetaApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.IdentityProfilesBetaApiFp)(configuration);
		    return {
		        /**
		         * This creates an Identity Profile A token with ORG_ADMIN authority is required to call this API to create an Identity Profile.
		         * @summary Create an Identity Profile
		         * @param {IdentityProfileBeta} identityProfileBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createIdentityProfile: function (identityProfileBeta, axiosOptions) {
		            return localVarFp.createIdentityProfile(identityProfileBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This deletes an Identity Profile based on ID.  On success, this endpoint will return a reference to the bulk delete task result.  A token with ORG_ADMIN authority is required to call this API.  The following rights are required to access this endpoint: idn:identity-profile:delete
		         * @summary Delete an Identity Profile
		         * @param {string} identityProfileId The Identity Profile ID.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteIdentityProfile: function (identityProfileId, axiosOptions) {
		            return localVarFp.deleteIdentityProfile(identityProfileId, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This deletes multiple Identity Profiles via a list of supplied IDs.  On success, this endpoint will return a reference to the bulk delete task result.  A token with ORG_ADMIN authority is required to call this API.  The following rights are required to access this endpoint: idn:identity-profile:delete
		         * @summary Delete Identity Profiles
		         * @param {Array<string>} requestBody Identity Profile bulk delete request body.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteIdentityProfiles: function (requestBody, axiosOptions) {
		            return localVarFp.deleteIdentityProfiles(requestBody, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This exports existing identity profiles in the format specified by the sp-config service.
		         * @summary Export Identity Profiles
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, ne*  **name**: *eq, ne*  **priority**: *eq, ne*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **id, name, priority**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        exportIdentityProfiles: function (limit, offset, count, filters, sorters, axiosOptions) {
		            return localVarFp.exportIdentityProfiles(limit, offset, count, filters, sorters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This generates a non-persisted IdentityDetails object that will represent as the preview of the identities attribute when the given policy\'s attribute config is applied. A token with ORG_ADMIN authority is required to call this API to generate an identity preview.
		         * @summary Generate Identity Profile Preview
		         * @param {IdentityPreviewRequestBeta} identityPreviewRequestBeta Identity Preview request body.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        generateIdentityPreview: function (identityPreviewRequestBeta, axiosOptions) {
		            return localVarFp.generateIdentityPreview(identityPreviewRequestBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This returns the default identity attribute config A token with ORG_ADMIN authority is required to call this API to get the default identity attribute config.
		         * @summary Default identity attribute config
		         * @param {string} identityProfileId The Identity Profile ID
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getDefaultIdentityAttributeConfig: function (identityProfileId, axiosOptions) {
		            return localVarFp.getDefaultIdentityAttributeConfig(identityProfileId, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This returns a single Identity Profile based on ID. A token with ORG_ADMIN or API authority is required to call this API.
		         * @summary Gets a single Identity Profile
		         * @param {string} identityProfileId The Identity Profile ID
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getIdentityProfile: function (identityProfileId, axiosOptions) {
		            return localVarFp.getIdentityProfile(identityProfileId, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This imports previously exported identity profiles.
		         * @summary Import Identity Profiles
		         * @param {Array<IdentityProfileExportedObjectBeta>} identityProfileExportedObjectBeta Previously exported Identity Profiles.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        importIdentityProfiles: function (identityProfileExportedObjectBeta, axiosOptions) {
		            return localVarFp.importIdentityProfiles(identityProfileExportedObjectBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This returns a list of Identity Profiles based on the specified query parameters. A token with ORG_ADMIN or API authority is required to call this API to get a list of Identity Profiles.
		         * @summary Identity Profiles list
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, ne, ge, gt, in, le, lt, isnull, sw*  **name**: *eq, ne, in, le, lt, isnull, sw*  **priority**: *eq, ne*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **id, name, priority, created, modified, owner.id, owner.name**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listIdentityProfiles: function (limit, offset, count, filters, sorters, axiosOptions) {
		            return localVarFp.listIdentityProfiles(limit, offset, count, filters, sorters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Process identities under the profile  A token with ORG_ADMIN authority is required to call this API.
		         * @summary Process identities under profile
		         * @param {string} identityProfileId The Identity Profile ID to be processed
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        syncIdentityProfile: function (identityProfileId, axiosOptions) {
		            return localVarFp.syncIdentityProfile(identityProfileId, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This updates the specified Identity Profile. A token with ORG_ADMIN authority is required to call this API to update the Identity Profile. Some fields of the Schema cannot be updated. These fields are listed below. * id * name * created * modified
		         * @summary Update the Identity Profile
		         * @param {string} identityProfileId The Identity Profile ID
		         * @param {Array<JsonPatchOperationBeta>} jsonPatchOperationBeta A list of Identity Profile update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateIdentityProfile: function (identityProfileId, jsonPatchOperationBeta, axiosOptions) {
		            return localVarFp.updateIdentityProfile(identityProfileId, jsonPatchOperationBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.IdentityProfilesBetaApiFactory = IdentityProfilesBetaApiFactory;
		/**
		 * IdentityProfilesBetaApi - object-oriented interface
		 * @export
		 * @class IdentityProfilesBetaApi
		 * @extends {BaseAPI}
		 */
		var IdentityProfilesBetaApi = /** @class */ (function (_super) {
		    __extends(IdentityProfilesBetaApi, _super);
		    function IdentityProfilesBetaApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * This creates an Identity Profile A token with ORG_ADMIN authority is required to call this API to create an Identity Profile.
		     * @summary Create an Identity Profile
		     * @param {IdentityProfilesBetaApiCreateIdentityProfileRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IdentityProfilesBetaApi
		     */
		    IdentityProfilesBetaApi.prototype.createIdentityProfile = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.IdentityProfilesBetaApiFp)(this.configuration).createIdentityProfile(requestParameters.identityProfileBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This deletes an Identity Profile based on ID.  On success, this endpoint will return a reference to the bulk delete task result.  A token with ORG_ADMIN authority is required to call this API.  The following rights are required to access this endpoint: idn:identity-profile:delete
		     * @summary Delete an Identity Profile
		     * @param {IdentityProfilesBetaApiDeleteIdentityProfileRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IdentityProfilesBetaApi
		     */
		    IdentityProfilesBetaApi.prototype.deleteIdentityProfile = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.IdentityProfilesBetaApiFp)(this.configuration).deleteIdentityProfile(requestParameters.identityProfileId, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This deletes multiple Identity Profiles via a list of supplied IDs.  On success, this endpoint will return a reference to the bulk delete task result.  A token with ORG_ADMIN authority is required to call this API.  The following rights are required to access this endpoint: idn:identity-profile:delete
		     * @summary Delete Identity Profiles
		     * @param {IdentityProfilesBetaApiDeleteIdentityProfilesRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IdentityProfilesBetaApi
		     */
		    IdentityProfilesBetaApi.prototype.deleteIdentityProfiles = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.IdentityProfilesBetaApiFp)(this.configuration).deleteIdentityProfiles(requestParameters.requestBody, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This exports existing identity profiles in the format specified by the sp-config service.
		     * @summary Export Identity Profiles
		     * @param {IdentityProfilesBetaApiExportIdentityProfilesRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IdentityProfilesBetaApi
		     */
		    IdentityProfilesBetaApi.prototype.exportIdentityProfiles = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.IdentityProfilesBetaApiFp)(this.configuration).exportIdentityProfiles(requestParameters.limit, requestParameters.offset, requestParameters.count, requestParameters.filters, requestParameters.sorters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This generates a non-persisted IdentityDetails object that will represent as the preview of the identities attribute when the given policy\'s attribute config is applied. A token with ORG_ADMIN authority is required to call this API to generate an identity preview.
		     * @summary Generate Identity Profile Preview
		     * @param {IdentityProfilesBetaApiGenerateIdentityPreviewRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IdentityProfilesBetaApi
		     */
		    IdentityProfilesBetaApi.prototype.generateIdentityPreview = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.IdentityProfilesBetaApiFp)(this.configuration).generateIdentityPreview(requestParameters.identityPreviewRequestBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This returns the default identity attribute config A token with ORG_ADMIN authority is required to call this API to get the default identity attribute config.
		     * @summary Default identity attribute config
		     * @param {IdentityProfilesBetaApiGetDefaultIdentityAttributeConfigRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IdentityProfilesBetaApi
		     */
		    IdentityProfilesBetaApi.prototype.getDefaultIdentityAttributeConfig = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.IdentityProfilesBetaApiFp)(this.configuration).getDefaultIdentityAttributeConfig(requestParameters.identityProfileId, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This returns a single Identity Profile based on ID. A token with ORG_ADMIN or API authority is required to call this API.
		     * @summary Gets a single Identity Profile
		     * @param {IdentityProfilesBetaApiGetIdentityProfileRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IdentityProfilesBetaApi
		     */
		    IdentityProfilesBetaApi.prototype.getIdentityProfile = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.IdentityProfilesBetaApiFp)(this.configuration).getIdentityProfile(requestParameters.identityProfileId, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This imports previously exported identity profiles.
		     * @summary Import Identity Profiles
		     * @param {IdentityProfilesBetaApiImportIdentityProfilesRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IdentityProfilesBetaApi
		     */
		    IdentityProfilesBetaApi.prototype.importIdentityProfiles = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.IdentityProfilesBetaApiFp)(this.configuration).importIdentityProfiles(requestParameters.identityProfileExportedObjectBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This returns a list of Identity Profiles based on the specified query parameters. A token with ORG_ADMIN or API authority is required to call this API to get a list of Identity Profiles.
		     * @summary Identity Profiles list
		     * @param {IdentityProfilesBetaApiListIdentityProfilesRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IdentityProfilesBetaApi
		     */
		    IdentityProfilesBetaApi.prototype.listIdentityProfiles = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.IdentityProfilesBetaApiFp)(this.configuration).listIdentityProfiles(requestParameters.limit, requestParameters.offset, requestParameters.count, requestParameters.filters, requestParameters.sorters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Process identities under the profile  A token with ORG_ADMIN authority is required to call this API.
		     * @summary Process identities under profile
		     * @param {IdentityProfilesBetaApiSyncIdentityProfileRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IdentityProfilesBetaApi
		     */
		    IdentityProfilesBetaApi.prototype.syncIdentityProfile = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.IdentityProfilesBetaApiFp)(this.configuration).syncIdentityProfile(requestParameters.identityProfileId, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This updates the specified Identity Profile. A token with ORG_ADMIN authority is required to call this API to update the Identity Profile. Some fields of the Schema cannot be updated. These fields are listed below. * id * name * created * modified
		     * @summary Update the Identity Profile
		     * @param {IdentityProfilesBetaApiUpdateIdentityProfileRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IdentityProfilesBetaApi
		     */
		    IdentityProfilesBetaApi.prototype.updateIdentityProfile = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.IdentityProfilesBetaApiFp)(this.configuration).updateIdentityProfile(requestParameters.identityProfileId, requestParameters.jsonPatchOperationBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return IdentityProfilesBetaApi;
		}(base_1.BaseAPI));
		exports.IdentityProfilesBetaApi = IdentityProfilesBetaApi;
		/**
		 * LifecycleStatesBetaApi - axios parameter creator
		 * @export
		 */
		var LifecycleStatesBetaApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * This endpoint returns a lifecycle state.  A token with ORG_ADMIN or API authority is required to call this API.
		         * @summary Lifecycle State
		         * @param {string} identityProfileId Identity Profile ID
		         * @param {string} lifecycleStateId Lifecycle State ID
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listLifecycleStates: function (identityProfileId, lifecycleStateId, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'identityProfileId' is not null or undefined
		                            (0, common_1.assertParamExists)('listLifecycleStates', 'identityProfileId', identityProfileId);
		                            // verify required parameter 'lifecycleStateId' is not null or undefined
		                            (0, common_1.assertParamExists)('listLifecycleStates', 'lifecycleStateId', lifecycleStateId);
		                            localVarPath = "/identity-profiles/{identity-profile-id}/lifecycle-states/{lifecycle-state-id}"
		                                .replace("{".concat("identity-profile-id", "}"), encodeURIComponent(String(identityProfileId)))
		                                .replace("{".concat("lifecycle-state-id", "}"), encodeURIComponent(String(lifecycleStateId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API updates individual lifecycle state fields using the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.  A token with ORG_ADMIN or API authority is required to call this API.
		         * @summary Update Lifecycle State
		         * @param {string} identityProfileId Identity Profile ID
		         * @param {string} lifecycleStateId Lifecycle State ID
		         * @param {Array<JsonPatchOperationBeta>} jsonPatchOperationBeta A list of lifecycle state update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.  The following fields can be updated: * enabled * description * accountActions * accessProfileIds * emailNotificationOption
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateLifecycleStates: function (identityProfileId, lifecycleStateId, jsonPatchOperationBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'identityProfileId' is not null or undefined
		                            (0, common_1.assertParamExists)('updateLifecycleStates', 'identityProfileId', identityProfileId);
		                            // verify required parameter 'lifecycleStateId' is not null or undefined
		                            (0, common_1.assertParamExists)('updateLifecycleStates', 'lifecycleStateId', lifecycleStateId);
		                            // verify required parameter 'jsonPatchOperationBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('updateLifecycleStates', 'jsonPatchOperationBeta', jsonPatchOperationBeta);
		                            localVarPath = "/identity-profiles/{identity-profile-id}/lifecycle-states/{lifecycle-state-id}"
		                                .replace("{".concat("identity-profile-id", "}"), encodeURIComponent(String(identityProfileId)))
		                                .replace("{".concat("lifecycle-state-id", "}"), encodeURIComponent(String(lifecycleStateId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PATCH' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json-patch+json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(jsonPatchOperationBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.LifecycleStatesBetaApiAxiosParamCreator = LifecycleStatesBetaApiAxiosParamCreator;
		/**
		 * LifecycleStatesBetaApi - functional programming interface
		 * @export
		 */
		var LifecycleStatesBetaApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.LifecycleStatesBetaApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * This endpoint returns a lifecycle state.  A token with ORG_ADMIN or API authority is required to call this API.
		         * @summary Lifecycle State
		         * @param {string} identityProfileId Identity Profile ID
		         * @param {string} lifecycleStateId Lifecycle State ID
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listLifecycleStates: function (identityProfileId, lifecycleStateId, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listLifecycleStates(identityProfileId, lifecycleStateId, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API updates individual lifecycle state fields using the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.  A token with ORG_ADMIN or API authority is required to call this API.
		         * @summary Update Lifecycle State
		         * @param {string} identityProfileId Identity Profile ID
		         * @param {string} lifecycleStateId Lifecycle State ID
		         * @param {Array<JsonPatchOperationBeta>} jsonPatchOperationBeta A list of lifecycle state update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.  The following fields can be updated: * enabled * description * accountActions * accessProfileIds * emailNotificationOption
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateLifecycleStates: function (identityProfileId, lifecycleStateId, jsonPatchOperationBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.updateLifecycleStates(identityProfileId, lifecycleStateId, jsonPatchOperationBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.LifecycleStatesBetaApiFp = LifecycleStatesBetaApiFp;
		/**
		 * LifecycleStatesBetaApi - factory interface
		 * @export
		 */
		var LifecycleStatesBetaApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.LifecycleStatesBetaApiFp)(configuration);
		    return {
		        /**
		         * This endpoint returns a lifecycle state.  A token with ORG_ADMIN or API authority is required to call this API.
		         * @summary Lifecycle State
		         * @param {string} identityProfileId Identity Profile ID
		         * @param {string} lifecycleStateId Lifecycle State ID
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listLifecycleStates: function (identityProfileId, lifecycleStateId, axiosOptions) {
		            return localVarFp.listLifecycleStates(identityProfileId, lifecycleStateId, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API updates individual lifecycle state fields using the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.  A token with ORG_ADMIN or API authority is required to call this API.
		         * @summary Update Lifecycle State
		         * @param {string} identityProfileId Identity Profile ID
		         * @param {string} lifecycleStateId Lifecycle State ID
		         * @param {Array<JsonPatchOperationBeta>} jsonPatchOperationBeta A list of lifecycle state update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.  The following fields can be updated: * enabled * description * accountActions * accessProfileIds * emailNotificationOption
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateLifecycleStates: function (identityProfileId, lifecycleStateId, jsonPatchOperationBeta, axiosOptions) {
		            return localVarFp.updateLifecycleStates(identityProfileId, lifecycleStateId, jsonPatchOperationBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.LifecycleStatesBetaApiFactory = LifecycleStatesBetaApiFactory;
		/**
		 * LifecycleStatesBetaApi - object-oriented interface
		 * @export
		 * @class LifecycleStatesBetaApi
		 * @extends {BaseAPI}
		 */
		var LifecycleStatesBetaApi = /** @class */ (function (_super) {
		    __extends(LifecycleStatesBetaApi, _super);
		    function LifecycleStatesBetaApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * This endpoint returns a lifecycle state.  A token with ORG_ADMIN or API authority is required to call this API.
		     * @summary Lifecycle State
		     * @param {LifecycleStatesBetaApiListLifecycleStatesRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof LifecycleStatesBetaApi
		     */
		    LifecycleStatesBetaApi.prototype.listLifecycleStates = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.LifecycleStatesBetaApiFp)(this.configuration).listLifecycleStates(requestParameters.identityProfileId, requestParameters.lifecycleStateId, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API updates individual lifecycle state fields using the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.  A token with ORG_ADMIN or API authority is required to call this API.
		     * @summary Update Lifecycle State
		     * @param {LifecycleStatesBetaApiUpdateLifecycleStatesRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof LifecycleStatesBetaApi
		     */
		    LifecycleStatesBetaApi.prototype.updateLifecycleStates = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.LifecycleStatesBetaApiFp)(this.configuration).updateLifecycleStates(requestParameters.identityProfileId, requestParameters.lifecycleStateId, requestParameters.jsonPatchOperationBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return LifecycleStatesBetaApi;
		}(base_1.BaseAPI));
		exports.LifecycleStatesBetaApi = LifecycleStatesBetaApi;
		/**
		 * MFAConfigurationBetaApi - axios parameter creator
		 * @export
		 */
		var MFAConfigurationBetaApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * This API removes the configuration for the specified MFA method. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Delete MFA method configuration
		         * @param {string} method The name of the MFA method. The currently supported method names are \&#39;okta-verify\&#39; and \&#39;duo-web\&#39;.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteMFAConfig: function (method, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'method' is not null or undefined
		                            (0, common_1.assertParamExists)('deleteMFAConfig', 'method', method);
		                            localVarPath = "/mfa/{method}/delete"
		                                .replace("{".concat("method", "}"), encodeURIComponent(String(method)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'DELETE' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns the configuration of an Duo MFA method. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Configuration of Duo MFA method
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getMFADuoConfig: function (axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/mfa/duo-web/config";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns the configuration of an Okta MFA method. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Configuration of Okta MFA method
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getMFAOktaConfig: function (axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/mfa/okta-verify/config";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API sets the configuration of an Duo MFA method. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Set Duo MFA configuration
		         * @param {MfaDuoConfigBeta} mfaDuoConfigBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        setMFADuoConfig: function (mfaDuoConfigBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'mfaDuoConfigBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('setMFADuoConfig', 'mfaDuoConfigBeta', mfaDuoConfigBeta);
		                            localVarPath = "/mfa/duo-web/config";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PUT' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(mfaDuoConfigBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API sets the configuration of an Okta MFA method. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Set Okta MFA configuration
		         * @param {MfaOktaConfigBeta} mfaOktaConfigBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        setMFAOktaConfig: function (mfaOktaConfigBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'mfaOktaConfigBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('setMFAOktaConfig', 'mfaOktaConfigBeta', mfaOktaConfigBeta);
		                            localVarPath = "/mfa/okta-verify/config";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PUT' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(mfaOktaConfigBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API validates that the configuration is valid and will properly authenticate with the MFA provider identified by the method path parameter. A token with ORG_ADMIN authority is required to call this API.
		         * @summary MFA method\'s test configuration
		         * @param {string} method The name of the MFA method. The currently supported method names are \&#39;okta-verify\&#39; and \&#39;duo-web\&#39;.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        testMFAConfig: function (method, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'method' is not null or undefined
		                            (0, common_1.assertParamExists)('testMFAConfig', 'method', method);
		                            localVarPath = "/mfa/{method}/test"
		                                .replace("{".concat("method", "}"), encodeURIComponent(String(method)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.MFAConfigurationBetaApiAxiosParamCreator = MFAConfigurationBetaApiAxiosParamCreator;
		/**
		 * MFAConfigurationBetaApi - functional programming interface
		 * @export
		 */
		var MFAConfigurationBetaApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.MFAConfigurationBetaApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * This API removes the configuration for the specified MFA method. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Delete MFA method configuration
		         * @param {string} method The name of the MFA method. The currently supported method names are \&#39;okta-verify\&#39; and \&#39;duo-web\&#39;.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteMFAConfig: function (method, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.deleteMFAConfig(method, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns the configuration of an Duo MFA method. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Configuration of Duo MFA method
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getMFADuoConfig: function (axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getMFADuoConfig(axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns the configuration of an Okta MFA method. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Configuration of Okta MFA method
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getMFAOktaConfig: function (axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getMFAOktaConfig(axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API sets the configuration of an Duo MFA method. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Set Duo MFA configuration
		         * @param {MfaDuoConfigBeta} mfaDuoConfigBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        setMFADuoConfig: function (mfaDuoConfigBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.setMFADuoConfig(mfaDuoConfigBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API sets the configuration of an Okta MFA method. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Set Okta MFA configuration
		         * @param {MfaOktaConfigBeta} mfaOktaConfigBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        setMFAOktaConfig: function (mfaOktaConfigBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.setMFAOktaConfig(mfaOktaConfigBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API validates that the configuration is valid and will properly authenticate with the MFA provider identified by the method path parameter. A token with ORG_ADMIN authority is required to call this API.
		         * @summary MFA method\'s test configuration
		         * @param {string} method The name of the MFA method. The currently supported method names are \&#39;okta-verify\&#39; and \&#39;duo-web\&#39;.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        testMFAConfig: function (method, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.testMFAConfig(method, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.MFAConfigurationBetaApiFp = MFAConfigurationBetaApiFp;
		/**
		 * MFAConfigurationBetaApi - factory interface
		 * @export
		 */
		var MFAConfigurationBetaApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.MFAConfigurationBetaApiFp)(configuration);
		    return {
		        /**
		         * This API removes the configuration for the specified MFA method. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Delete MFA method configuration
		         * @param {string} method The name of the MFA method. The currently supported method names are \&#39;okta-verify\&#39; and \&#39;duo-web\&#39;.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteMFAConfig: function (method, axiosOptions) {
		            return localVarFp.deleteMFAConfig(method, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API returns the configuration of an Duo MFA method. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Configuration of Duo MFA method
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getMFADuoConfig: function (axiosOptions) {
		            return localVarFp.getMFADuoConfig(axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API returns the configuration of an Okta MFA method. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Configuration of Okta MFA method
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getMFAOktaConfig: function (axiosOptions) {
		            return localVarFp.getMFAOktaConfig(axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API sets the configuration of an Duo MFA method. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Set Duo MFA configuration
		         * @param {MfaDuoConfigBeta} mfaDuoConfigBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        setMFADuoConfig: function (mfaDuoConfigBeta, axiosOptions) {
		            return localVarFp.setMFADuoConfig(mfaDuoConfigBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API sets the configuration of an Okta MFA method. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Set Okta MFA configuration
		         * @param {MfaOktaConfigBeta} mfaOktaConfigBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        setMFAOktaConfig: function (mfaOktaConfigBeta, axiosOptions) {
		            return localVarFp.setMFAOktaConfig(mfaOktaConfigBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API validates that the configuration is valid and will properly authenticate with the MFA provider identified by the method path parameter. A token with ORG_ADMIN authority is required to call this API.
		         * @summary MFA method\'s test configuration
		         * @param {string} method The name of the MFA method. The currently supported method names are \&#39;okta-verify\&#39; and \&#39;duo-web\&#39;.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        testMFAConfig: function (method, axiosOptions) {
		            return localVarFp.testMFAConfig(method, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.MFAConfigurationBetaApiFactory = MFAConfigurationBetaApiFactory;
		/**
		 * MFAConfigurationBetaApi - object-oriented interface
		 * @export
		 * @class MFAConfigurationBetaApi
		 * @extends {BaseAPI}
		 */
		var MFAConfigurationBetaApi = /** @class */ (function (_super) {
		    __extends(MFAConfigurationBetaApi, _super);
		    function MFAConfigurationBetaApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * This API removes the configuration for the specified MFA method. A token with ORG_ADMIN authority is required to call this API.
		     * @summary Delete MFA method configuration
		     * @param {MFAConfigurationBetaApiDeleteMFAConfigRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof MFAConfigurationBetaApi
		     */
		    MFAConfigurationBetaApi.prototype.deleteMFAConfig = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.MFAConfigurationBetaApiFp)(this.configuration).deleteMFAConfig(requestParameters.method, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API returns the configuration of an Duo MFA method. A token with ORG_ADMIN authority is required to call this API.
		     * @summary Configuration of Duo MFA method
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof MFAConfigurationBetaApi
		     */
		    MFAConfigurationBetaApi.prototype.getMFADuoConfig = function (axiosOptions) {
		        var _this = this;
		        return (0, exports.MFAConfigurationBetaApiFp)(this.configuration).getMFADuoConfig(axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API returns the configuration of an Okta MFA method. A token with ORG_ADMIN authority is required to call this API.
		     * @summary Configuration of Okta MFA method
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof MFAConfigurationBetaApi
		     */
		    MFAConfigurationBetaApi.prototype.getMFAOktaConfig = function (axiosOptions) {
		        var _this = this;
		        return (0, exports.MFAConfigurationBetaApiFp)(this.configuration).getMFAOktaConfig(axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API sets the configuration of an Duo MFA method. A token with ORG_ADMIN authority is required to call this API.
		     * @summary Set Duo MFA configuration
		     * @param {MFAConfigurationBetaApiSetMFADuoConfigRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof MFAConfigurationBetaApi
		     */
		    MFAConfigurationBetaApi.prototype.setMFADuoConfig = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.MFAConfigurationBetaApiFp)(this.configuration).setMFADuoConfig(requestParameters.mfaDuoConfigBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API sets the configuration of an Okta MFA method. A token with ORG_ADMIN authority is required to call this API.
		     * @summary Set Okta MFA configuration
		     * @param {MFAConfigurationBetaApiSetMFAOktaConfigRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof MFAConfigurationBetaApi
		     */
		    MFAConfigurationBetaApi.prototype.setMFAOktaConfig = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.MFAConfigurationBetaApiFp)(this.configuration).setMFAOktaConfig(requestParameters.mfaOktaConfigBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API validates that the configuration is valid and will properly authenticate with the MFA provider identified by the method path parameter. A token with ORG_ADMIN authority is required to call this API.
		     * @summary MFA method\'s test configuration
		     * @param {MFAConfigurationBetaApiTestMFAConfigRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof MFAConfigurationBetaApi
		     */
		    MFAConfigurationBetaApi.prototype.testMFAConfig = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.MFAConfigurationBetaApiFp)(this.configuration).testMFAConfig(requestParameters.method, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return MFAConfigurationBetaApi;
		}(base_1.BaseAPI));
		exports.MFAConfigurationBetaApi = MFAConfigurationBetaApi;
		/**
		 * MFAControllerBetaApi - axios parameter creator
		 * @export
		 */
		var MFAControllerBetaApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * This API send token request.
		         * @summary Create and send user token
		         * @param {SendTokenRequestBeta} sendTokenRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createSendToken: function (sendTokenRequestBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'sendTokenRequestBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('createSendToken', 'sendTokenRequestBeta', sendTokenRequestBeta);
		                            localVarPath = "/mfa/token/send";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(sendTokenRequestBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API poll the VerificationPollRequest for the specified MFA method. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Polling MFA method by VerificationPollRequest
		         * @param {string} method The name of the MFA method. The currently supported method names are \&#39;okta-verify\&#39;, \&#39;duo-web\&#39;, \&#39;kba\&#39;,\&#39;token\&#39;, \&#39;rsa\&#39;
		         * @param {VerificationPollRequestBeta} verificationPollRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        pingVerificationStatus: function (method, verificationPollRequestBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'method' is not null or undefined
		                            (0, common_1.assertParamExists)('pingVerificationStatus', 'method', method);
		                            // verify required parameter 'verificationPollRequestBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('pingVerificationStatus', 'verificationPollRequestBeta', verificationPollRequestBeta);
		                            localVarPath = "/mfa/{method}/poll"
		                                .replace("{".concat("method", "}"), encodeURIComponent(String(method)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(verificationPollRequestBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API Authenticates the user via Duo-Web MFA method.
		         * @summary Verifying authentication via Duo method
		         * @param {DuoVerificationRequestBeta} duoVerificationRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        sendDuoVerifyRequest: function (duoVerificationRequestBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'duoVerificationRequestBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('sendDuoVerifyRequest', 'duoVerificationRequestBeta', duoVerificationRequestBeta);
		                            localVarPath = "/mfa/duo-web/verify";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(duoVerificationRequestBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API Authenticate user in KBA MFA method.
		         * @summary Authenticate KBA provided MFA method
		         * @param {KbaAnswerRequestBeta} kbaAnswerRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        sendKbaAnswers: function (kbaAnswerRequestBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'kbaAnswerRequestBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('sendKbaAnswers', 'kbaAnswerRequestBeta', kbaAnswerRequestBeta);
		                            localVarPath = "/mfa/kba/authenticate";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(kbaAnswerRequestBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API Authenticates the user via Okta-Verify MFA method. Request requires a header called \'slpt-forwarding\', and it must contain a remote IP Address of caller.
		         * @summary Verifying authentication via Okta method
		         * @param {OktaVerificationRequestBeta} oktaVerificationRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        sendOktaVerifyRequest: function (oktaVerificationRequestBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'oktaVerificationRequestBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('sendOktaVerifyRequest', 'oktaVerificationRequestBeta', oktaVerificationRequestBeta);
		                            localVarPath = "/mfa/okta-verify/verify";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(oktaVerificationRequestBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API Authenticate user in Token MFA method.
		         * @summary Authenticate Token provided MFA method
		         * @param {TokenAuthRequestBeta} tokenAuthRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        sendTokenAuthRequest: function (tokenAuthRequestBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'tokenAuthRequestBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('sendTokenAuthRequest', 'tokenAuthRequestBeta', tokenAuthRequestBeta);
		                            localVarPath = "/mfa/token/authenticate";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(tokenAuthRequestBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.MFAControllerBetaApiAxiosParamCreator = MFAControllerBetaApiAxiosParamCreator;
		/**
		 * MFAControllerBetaApi - functional programming interface
		 * @export
		 */
		var MFAControllerBetaApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.MFAControllerBetaApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * This API send token request.
		         * @summary Create and send user token
		         * @param {SendTokenRequestBeta} sendTokenRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createSendToken: function (sendTokenRequestBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.createSendToken(sendTokenRequestBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API poll the VerificationPollRequest for the specified MFA method. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Polling MFA method by VerificationPollRequest
		         * @param {string} method The name of the MFA method. The currently supported method names are \&#39;okta-verify\&#39;, \&#39;duo-web\&#39;, \&#39;kba\&#39;,\&#39;token\&#39;, \&#39;rsa\&#39;
		         * @param {VerificationPollRequestBeta} verificationPollRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        pingVerificationStatus: function (method, verificationPollRequestBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.pingVerificationStatus(method, verificationPollRequestBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API Authenticates the user via Duo-Web MFA method.
		         * @summary Verifying authentication via Duo method
		         * @param {DuoVerificationRequestBeta} duoVerificationRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        sendDuoVerifyRequest: function (duoVerificationRequestBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.sendDuoVerifyRequest(duoVerificationRequestBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API Authenticate user in KBA MFA method.
		         * @summary Authenticate KBA provided MFA method
		         * @param {KbaAnswerRequestBeta} kbaAnswerRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        sendKbaAnswers: function (kbaAnswerRequestBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.sendKbaAnswers(kbaAnswerRequestBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API Authenticates the user via Okta-Verify MFA method. Request requires a header called \'slpt-forwarding\', and it must contain a remote IP Address of caller.
		         * @summary Verifying authentication via Okta method
		         * @param {OktaVerificationRequestBeta} oktaVerificationRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        sendOktaVerifyRequest: function (oktaVerificationRequestBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.sendOktaVerifyRequest(oktaVerificationRequestBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API Authenticate user in Token MFA method.
		         * @summary Authenticate Token provided MFA method
		         * @param {TokenAuthRequestBeta} tokenAuthRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        sendTokenAuthRequest: function (tokenAuthRequestBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.sendTokenAuthRequest(tokenAuthRequestBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.MFAControllerBetaApiFp = MFAControllerBetaApiFp;
		/**
		 * MFAControllerBetaApi - factory interface
		 * @export
		 */
		var MFAControllerBetaApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.MFAControllerBetaApiFp)(configuration);
		    return {
		        /**
		         * This API send token request.
		         * @summary Create and send user token
		         * @param {SendTokenRequestBeta} sendTokenRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createSendToken: function (sendTokenRequestBeta, axiosOptions) {
		            return localVarFp.createSendToken(sendTokenRequestBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API poll the VerificationPollRequest for the specified MFA method. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Polling MFA method by VerificationPollRequest
		         * @param {string} method The name of the MFA method. The currently supported method names are \&#39;okta-verify\&#39;, \&#39;duo-web\&#39;, \&#39;kba\&#39;,\&#39;token\&#39;, \&#39;rsa\&#39;
		         * @param {VerificationPollRequestBeta} verificationPollRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        pingVerificationStatus: function (method, verificationPollRequestBeta, axiosOptions) {
		            return localVarFp.pingVerificationStatus(method, verificationPollRequestBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API Authenticates the user via Duo-Web MFA method.
		         * @summary Verifying authentication via Duo method
		         * @param {DuoVerificationRequestBeta} duoVerificationRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        sendDuoVerifyRequest: function (duoVerificationRequestBeta, axiosOptions) {
		            return localVarFp.sendDuoVerifyRequest(duoVerificationRequestBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API Authenticate user in KBA MFA method.
		         * @summary Authenticate KBA provided MFA method
		         * @param {KbaAnswerRequestBeta} kbaAnswerRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        sendKbaAnswers: function (kbaAnswerRequestBeta, axiosOptions) {
		            return localVarFp.sendKbaAnswers(kbaAnswerRequestBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API Authenticates the user via Okta-Verify MFA method. Request requires a header called \'slpt-forwarding\', and it must contain a remote IP Address of caller.
		         * @summary Verifying authentication via Okta method
		         * @param {OktaVerificationRequestBeta} oktaVerificationRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        sendOktaVerifyRequest: function (oktaVerificationRequestBeta, axiosOptions) {
		            return localVarFp.sendOktaVerifyRequest(oktaVerificationRequestBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API Authenticate user in Token MFA method.
		         * @summary Authenticate Token provided MFA method
		         * @param {TokenAuthRequestBeta} tokenAuthRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        sendTokenAuthRequest: function (tokenAuthRequestBeta, axiosOptions) {
		            return localVarFp.sendTokenAuthRequest(tokenAuthRequestBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.MFAControllerBetaApiFactory = MFAControllerBetaApiFactory;
		/**
		 * MFAControllerBetaApi - object-oriented interface
		 * @export
		 * @class MFAControllerBetaApi
		 * @extends {BaseAPI}
		 */
		var MFAControllerBetaApi = /** @class */ (function (_super) {
		    __extends(MFAControllerBetaApi, _super);
		    function MFAControllerBetaApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * This API send token request.
		     * @summary Create and send user token
		     * @param {MFAControllerBetaApiCreateSendTokenRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof MFAControllerBetaApi
		     */
		    MFAControllerBetaApi.prototype.createSendToken = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.MFAControllerBetaApiFp)(this.configuration).createSendToken(requestParameters.sendTokenRequestBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API poll the VerificationPollRequest for the specified MFA method. A token with ORG_ADMIN authority is required to call this API.
		     * @summary Polling MFA method by VerificationPollRequest
		     * @param {MFAControllerBetaApiPingVerificationStatusRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof MFAControllerBetaApi
		     */
		    MFAControllerBetaApi.prototype.pingVerificationStatus = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.MFAControllerBetaApiFp)(this.configuration).pingVerificationStatus(requestParameters.method, requestParameters.verificationPollRequestBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API Authenticates the user via Duo-Web MFA method.
		     * @summary Verifying authentication via Duo method
		     * @param {MFAControllerBetaApiSendDuoVerifyRequestRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof MFAControllerBetaApi
		     */
		    MFAControllerBetaApi.prototype.sendDuoVerifyRequest = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.MFAControllerBetaApiFp)(this.configuration).sendDuoVerifyRequest(requestParameters.duoVerificationRequestBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API Authenticate user in KBA MFA method.
		     * @summary Authenticate KBA provided MFA method
		     * @param {MFAControllerBetaApiSendKbaAnswersRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof MFAControllerBetaApi
		     */
		    MFAControllerBetaApi.prototype.sendKbaAnswers = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.MFAControllerBetaApiFp)(this.configuration).sendKbaAnswers(requestParameters.kbaAnswerRequestBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API Authenticates the user via Okta-Verify MFA method. Request requires a header called \'slpt-forwarding\', and it must contain a remote IP Address of caller.
		     * @summary Verifying authentication via Okta method
		     * @param {MFAControllerBetaApiSendOktaVerifyRequestRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof MFAControllerBetaApi
		     */
		    MFAControllerBetaApi.prototype.sendOktaVerifyRequest = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.MFAControllerBetaApiFp)(this.configuration).sendOktaVerifyRequest(requestParameters.oktaVerificationRequestBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API Authenticate user in Token MFA method.
		     * @summary Authenticate Token provided MFA method
		     * @param {MFAControllerBetaApiSendTokenAuthRequestRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof MFAControllerBetaApi
		     */
		    MFAControllerBetaApi.prototype.sendTokenAuthRequest = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.MFAControllerBetaApiFp)(this.configuration).sendTokenAuthRequest(requestParameters.tokenAuthRequestBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return MFAControllerBetaApi;
		}(base_1.BaseAPI));
		exports.MFAControllerBetaApi = MFAControllerBetaApi;
		/**
		 * ManagedClientsBetaApi - axios parameter creator
		 * @export
		 */
		var ManagedClientsBetaApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * Retrieve Managed Client Status by ID.
		         * @summary Specified Managed Client Status.
		         * @param {string} id ID of the Managed Client Status to get
		         * @param {ManagedClientTypeBeta} type Type of the Managed Client Status to get
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getManagedClientStatus: function (id, type, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getManagedClientStatus', 'id', id);
		                            // verify required parameter 'type' is not null or undefined
		                            (0, common_1.assertParamExists)('getManagedClientStatus', 'type', type);
		                            localVarPath = "/managed-clients/{id}/status"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (type !== undefined) {
		                                localVarQueryParameter['type'] = type;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Update a status detail passed in from the client
		         * @summary Handle status request from client
		         * @param {string} id ID of the Managed Client Status to update
		         * @param {ManagedClientStatusBeta} managedClientStatusBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateManagedClientStatus: function (id, managedClientStatusBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('updateManagedClientStatus', 'id', id);
		                            // verify required parameter 'managedClientStatusBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('updateManagedClientStatus', 'managedClientStatusBeta', managedClientStatusBeta);
		                            localVarPath = "/managed-clients/{id}/status"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(managedClientStatusBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.ManagedClientsBetaApiAxiosParamCreator = ManagedClientsBetaApiAxiosParamCreator;
		/**
		 * ManagedClientsBetaApi - functional programming interface
		 * @export
		 */
		var ManagedClientsBetaApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.ManagedClientsBetaApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * Retrieve Managed Client Status by ID.
		         * @summary Specified Managed Client Status.
		         * @param {string} id ID of the Managed Client Status to get
		         * @param {ManagedClientTypeBeta} type Type of the Managed Client Status to get
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getManagedClientStatus: function (id, type, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getManagedClientStatus(id, type, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Update a status detail passed in from the client
		         * @summary Handle status request from client
		         * @param {string} id ID of the Managed Client Status to update
		         * @param {ManagedClientStatusBeta} managedClientStatusBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateManagedClientStatus: function (id, managedClientStatusBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.updateManagedClientStatus(id, managedClientStatusBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.ManagedClientsBetaApiFp = ManagedClientsBetaApiFp;
		/**
		 * ManagedClientsBetaApi - factory interface
		 * @export
		 */
		var ManagedClientsBetaApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.ManagedClientsBetaApiFp)(configuration);
		    return {
		        /**
		         * Retrieve Managed Client Status by ID.
		         * @summary Specified Managed Client Status.
		         * @param {string} id ID of the Managed Client Status to get
		         * @param {ManagedClientTypeBeta} type Type of the Managed Client Status to get
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getManagedClientStatus: function (id, type, axiosOptions) {
		            return localVarFp.getManagedClientStatus(id, type, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Update a status detail passed in from the client
		         * @summary Handle status request from client
		         * @param {string} id ID of the Managed Client Status to update
		         * @param {ManagedClientStatusBeta} managedClientStatusBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateManagedClientStatus: function (id, managedClientStatusBeta, axiosOptions) {
		            return localVarFp.updateManagedClientStatus(id, managedClientStatusBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.ManagedClientsBetaApiFactory = ManagedClientsBetaApiFactory;
		/**
		 * ManagedClientsBetaApi - object-oriented interface
		 * @export
		 * @class ManagedClientsBetaApi
		 * @extends {BaseAPI}
		 */
		var ManagedClientsBetaApi = /** @class */ (function (_super) {
		    __extends(ManagedClientsBetaApi, _super);
		    function ManagedClientsBetaApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * Retrieve Managed Client Status by ID.
		     * @summary Specified Managed Client Status.
		     * @param {ManagedClientsBetaApiGetManagedClientStatusRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof ManagedClientsBetaApi
		     */
		    ManagedClientsBetaApi.prototype.getManagedClientStatus = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.ManagedClientsBetaApiFp)(this.configuration).getManagedClientStatus(requestParameters.id, requestParameters.type, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Update a status detail passed in from the client
		     * @summary Handle status request from client
		     * @param {ManagedClientsBetaApiUpdateManagedClientStatusRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof ManagedClientsBetaApi
		     */
		    ManagedClientsBetaApi.prototype.updateManagedClientStatus = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.ManagedClientsBetaApiFp)(this.configuration).updateManagedClientStatus(requestParameters.id, requestParameters.managedClientStatusBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return ManagedClientsBetaApi;
		}(base_1.BaseAPI));
		exports.ManagedClientsBetaApi = ManagedClientsBetaApi;
		/**
		 * ManagedClustersBetaApi - axios parameter creator
		 * @export
		 */
		var ManagedClustersBetaApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * Get managed cluster\'s log configuration.
		         * @summary Get managed cluster\'s log configuration
		         * @param {string} id ID of ManagedCluster to get log configuration for
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getClientLogConfiguration: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getClientLogConfiguration', 'id', id);
		                            localVarPath = "/managed-clusters/{id}/log-config"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Retrieve a ManagedCluster by ID.
		         * @summary Get a specified ManagedCluster.
		         * @param {string} id ID of the ManagedCluster to get
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getManagedCluster: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getManagedCluster', 'id', id);
		                            localVarPath = "/managed-clusters/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Retrieve all Managed Clusters for the current Org, based on request context.
		         * @summary Retrieve all Managed Clusters.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **operational**: *eq*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getManagedClusters: function (offset, limit, count, filters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/managed-clusters";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Update managed cluster\'s log configuration
		         * @summary Update managed cluster\'s log configuration
		         * @param {string} id ID of ManagedCluster to update log configuration for
		         * @param {ClientLogConfigurationBeta} clientLogConfigurationBeta ClientLogConfiguration for given ManagedCluster
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putClientLogConfiguration: function (id, clientLogConfigurationBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('putClientLogConfiguration', 'id', id);
		                            // verify required parameter 'clientLogConfigurationBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('putClientLogConfiguration', 'clientLogConfigurationBeta', clientLogConfigurationBeta);
		                            localVarPath = "/managed-clusters/{id}/log-config"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PUT' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(clientLogConfigurationBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.ManagedClustersBetaApiAxiosParamCreator = ManagedClustersBetaApiAxiosParamCreator;
		/**
		 * ManagedClustersBetaApi - functional programming interface
		 * @export
		 */
		var ManagedClustersBetaApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.ManagedClustersBetaApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * Get managed cluster\'s log configuration.
		         * @summary Get managed cluster\'s log configuration
		         * @param {string} id ID of ManagedCluster to get log configuration for
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getClientLogConfiguration: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getClientLogConfiguration(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Retrieve a ManagedCluster by ID.
		         * @summary Get a specified ManagedCluster.
		         * @param {string} id ID of the ManagedCluster to get
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getManagedCluster: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getManagedCluster(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Retrieve all Managed Clusters for the current Org, based on request context.
		         * @summary Retrieve all Managed Clusters.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **operational**: *eq*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getManagedClusters: function (offset, limit, count, filters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getManagedClusters(offset, limit, count, filters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Update managed cluster\'s log configuration
		         * @summary Update managed cluster\'s log configuration
		         * @param {string} id ID of ManagedCluster to update log configuration for
		         * @param {ClientLogConfigurationBeta} clientLogConfigurationBeta ClientLogConfiguration for given ManagedCluster
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putClientLogConfiguration: function (id, clientLogConfigurationBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.putClientLogConfiguration(id, clientLogConfigurationBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.ManagedClustersBetaApiFp = ManagedClustersBetaApiFp;
		/**
		 * ManagedClustersBetaApi - factory interface
		 * @export
		 */
		var ManagedClustersBetaApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.ManagedClustersBetaApiFp)(configuration);
		    return {
		        /**
		         * Get managed cluster\'s log configuration.
		         * @summary Get managed cluster\'s log configuration
		         * @param {string} id ID of ManagedCluster to get log configuration for
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getClientLogConfiguration: function (id, axiosOptions) {
		            return localVarFp.getClientLogConfiguration(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Retrieve a ManagedCluster by ID.
		         * @summary Get a specified ManagedCluster.
		         * @param {string} id ID of the ManagedCluster to get
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getManagedCluster: function (id, axiosOptions) {
		            return localVarFp.getManagedCluster(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Retrieve all Managed Clusters for the current Org, based on request context.
		         * @summary Retrieve all Managed Clusters.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **operational**: *eq*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getManagedClusters: function (offset, limit, count, filters, axiosOptions) {
		            return localVarFp.getManagedClusters(offset, limit, count, filters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Update managed cluster\'s log configuration
		         * @summary Update managed cluster\'s log configuration
		         * @param {string} id ID of ManagedCluster to update log configuration for
		         * @param {ClientLogConfigurationBeta} clientLogConfigurationBeta ClientLogConfiguration for given ManagedCluster
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putClientLogConfiguration: function (id, clientLogConfigurationBeta, axiosOptions) {
		            return localVarFp.putClientLogConfiguration(id, clientLogConfigurationBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.ManagedClustersBetaApiFactory = ManagedClustersBetaApiFactory;
		/**
		 * ManagedClustersBetaApi - object-oriented interface
		 * @export
		 * @class ManagedClustersBetaApi
		 * @extends {BaseAPI}
		 */
		var ManagedClustersBetaApi = /** @class */ (function (_super) {
		    __extends(ManagedClustersBetaApi, _super);
		    function ManagedClustersBetaApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * Get managed cluster\'s log configuration.
		     * @summary Get managed cluster\'s log configuration
		     * @param {ManagedClustersBetaApiGetClientLogConfigurationRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof ManagedClustersBetaApi
		     */
		    ManagedClustersBetaApi.prototype.getClientLogConfiguration = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.ManagedClustersBetaApiFp)(this.configuration).getClientLogConfiguration(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Retrieve a ManagedCluster by ID.
		     * @summary Get a specified ManagedCluster.
		     * @param {ManagedClustersBetaApiGetManagedClusterRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof ManagedClustersBetaApi
		     */
		    ManagedClustersBetaApi.prototype.getManagedCluster = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.ManagedClustersBetaApiFp)(this.configuration).getManagedCluster(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Retrieve all Managed Clusters for the current Org, based on request context.
		     * @summary Retrieve all Managed Clusters.
		     * @param {ManagedClustersBetaApiGetManagedClustersRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof ManagedClustersBetaApi
		     */
		    ManagedClustersBetaApi.prototype.getManagedClusters = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.ManagedClustersBetaApiFp)(this.configuration).getManagedClusters(requestParameters.offset, requestParameters.limit, requestParameters.count, requestParameters.filters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Update managed cluster\'s log configuration
		     * @summary Update managed cluster\'s log configuration
		     * @param {ManagedClustersBetaApiPutClientLogConfigurationRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof ManagedClustersBetaApi
		     */
		    ManagedClustersBetaApi.prototype.putClientLogConfiguration = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.ManagedClustersBetaApiFp)(this.configuration).putClientLogConfiguration(requestParameters.id, requestParameters.clientLogConfigurationBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return ManagedClustersBetaApi;
		}(base_1.BaseAPI));
		exports.ManagedClustersBetaApi = ManagedClustersBetaApi;
		/**
		 * NonEmployeeLifecycleManagementBetaApi - axios parameter creator
		 * @export
		 */
		var NonEmployeeLifecycleManagementBetaApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * Approves a non-employee approval request and notifies the next approver.
		         * @summary Approve a Non-Employee Request
		         * @param {string} id Non-Employee approval item id (UUID)
		         * @param {NonEmployeeApprovalDecisionBeta} nonEmployeeApprovalDecisionBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        approveNonEmployeeRequest: function (id, nonEmployeeApprovalDecisionBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('approveNonEmployeeRequest', 'id', id);
		                            // verify required parameter 'nonEmployeeApprovalDecisionBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('approveNonEmployeeRequest', 'nonEmployeeApprovalDecisionBeta', nonEmployeeApprovalDecisionBeta);
		                            localVarPath = "/non-employee-approvals/{id}/approve"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(nonEmployeeApprovalDecisionBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This request will create a non-employee record. Request will require the following security scope: \'idn:nesr:create\'
		         * @summary Create Non-Employee Record
		         * @param {NonEmployeeRequestBodyBeta} nonEmployeeRequestBodyBeta Non-Employee record creation request body.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createNonEmployeeRecord: function (nonEmployeeRequestBodyBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'nonEmployeeRequestBodyBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('createNonEmployeeRecord', 'nonEmployeeRequestBodyBeta', nonEmployeeRequestBodyBeta);
		                            localVarPath = "/non-employee-records";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(nonEmployeeRequestBodyBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This request will create a non-employee request and notify the approver
		         * @summary Create Non-Employee Request
		         * @param {NonEmployeeRequestBodyBeta} nonEmployeeRequestBodyBeta Non-Employee creation request body
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createNonEmployeeRequest: function (nonEmployeeRequestBodyBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'nonEmployeeRequestBodyBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('createNonEmployeeRequest', 'nonEmployeeRequestBodyBeta', nonEmployeeRequestBodyBeta);
		                            localVarPath = "/non-employee-requests";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(nonEmployeeRequestBodyBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This request will create a non-employee source. Request will require the following security scope: \'idn:nesr:create\'
		         * @summary Create Non-Employee Source
		         * @param {NonEmployeeSourceRequestBodyBeta} nonEmployeeSourceRequestBodyBeta Non-Employee source creation request body.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createNonEmployeeSource: function (nonEmployeeSourceRequestBodyBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'nonEmployeeSourceRequestBodyBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('createNonEmployeeSource', 'nonEmployeeSourceRequestBodyBeta', nonEmployeeSourceRequestBodyBeta);
		                            localVarPath = "/non-employee-sources";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(nonEmployeeSourceRequestBodyBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API creates a new schema attribute for Non-Employee Source. The schema technical name must be unique in the source. Attempts to create a schema attribute with an existing name will result in a \"400.1.409 Reference conflict\" response. At most, 10 custom attributes can be created per schema. Attempts to create more than 10 will result in a \"400.1.4 Limit violation\" response.
		         * @summary Create Non-Employee Source Schema Attribute
		         * @param {string} sourceId The Source id
		         * @param {NonEmployeeSchemaAttributeBodyBeta} nonEmployeeSchemaAttributeBodyBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createNonEmployeeSourceSchemaAttributes: function (sourceId, nonEmployeeSchemaAttributeBodyBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'sourceId' is not null or undefined
		                            (0, common_1.assertParamExists)('createNonEmployeeSourceSchemaAttributes', 'sourceId', sourceId);
		                            // verify required parameter 'nonEmployeeSchemaAttributeBodyBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('createNonEmployeeSourceSchemaAttributes', 'nonEmployeeSchemaAttributeBodyBeta', nonEmployeeSchemaAttributeBodyBeta);
		                            localVarPath = "/non-employee-sources/{sourceId}/schema-attributes"
		                                .replace("{".concat("sourceId", "}"), encodeURIComponent(String(sourceId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(nonEmployeeSchemaAttributeBodyBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This request will delete a non-employee record.
		         * @summary Delete Non-Employee Record
		         * @param {string} id Non-Employee record id (UUID)
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteNonEmployeeRecord: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('deleteNonEmployeeRecord', 'id', id);
		                            localVarPath = "/non-employee-records/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'DELETE' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This request will delete multiple non-employee records based on the non-employee ids provided. Request will require the following scope: \'idn:nesr:delete\'
		         * @summary Delete Multiple Non-Employee Records
		         * @param {DeleteNonEmployeeRecordInBulkRequestBeta} deleteNonEmployeeRecordInBulkRequestBeta Non-Employee bulk delete request body.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteNonEmployeeRecordInBulk: function (deleteNonEmployeeRecordInBulkRequestBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'deleteNonEmployeeRecordInBulkRequestBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('deleteNonEmployeeRecordInBulk', 'deleteNonEmployeeRecordInBulkRequestBeta', deleteNonEmployeeRecordInBulkRequestBeta);
		                            localVarPath = "/non-employee-records/bulk-delete";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(deleteNonEmployeeRecordInBulkRequestBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This request will delete a non-employee request.
		         * @summary Delete Non-Employee Request
		         * @param {string} id Non-Employee request id in the UUID format
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteNonEmployeeRequest: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('deleteNonEmployeeRequest', 'id', id);
		                            localVarPath = "/non-employee-requests/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'DELETE' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This end-point deletes a specific schema attribute for a non-employee source.
		         * @summary Delete Non-Employee Source\'s Schema Attribute
		         * @param {string} attributeId The Schema Attribute Id (UUID)
		         * @param {string} sourceId The Source id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteNonEmployeeSchemaAttribute: function (attributeId, sourceId, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'attributeId' is not null or undefined
		                            (0, common_1.assertParamExists)('deleteNonEmployeeSchemaAttribute', 'attributeId', attributeId);
		                            // verify required parameter 'sourceId' is not null or undefined
		                            (0, common_1.assertParamExists)('deleteNonEmployeeSchemaAttribute', 'sourceId', sourceId);
		                            localVarPath = "/non-employee-sources/{sourceId}/schema-attributes/{attributeId}"
		                                .replace("{".concat("attributeId", "}"), encodeURIComponent(String(attributeId)))
		                                .replace("{".concat("sourceId", "}"), encodeURIComponent(String(sourceId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'DELETE' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This request will delete a non-employee source.
		         * @summary Delete Non-Employee Source
		         * @param {string} sourceId Source Id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteNonEmployeeSource: function (sourceId, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'sourceId' is not null or undefined
		                            (0, common_1.assertParamExists)('deleteNonEmployeeSource', 'sourceId', sourceId);
		                            localVarPath = "/non-employee-sources/{sourceId}"
		                                .replace("{".concat("sourceId", "}"), encodeURIComponent(String(sourceId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'DELETE' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This end-point deletes all custom schema attributes for a non-employee source.
		         * @summary Delete all custom schema attributes
		         * @param {string} sourceId The Source id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteNonEmployeeSourceSchemaAttributes: function (sourceId, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'sourceId' is not null or undefined
		                            (0, common_1.assertParamExists)('deleteNonEmployeeSourceSchemaAttributes', 'sourceId', sourceId);
		                            localVarPath = "/non-employee-sources/{sourceId}/schema-attributes"
		                                .replace("{".concat("sourceId", "}"), encodeURIComponent(String(sourceId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'DELETE' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This requests a CSV download for all non-employees from a provided source.
		         * @summary Exports Non-Employee Records to CSV
		         * @param {string} id Source Id (UUID)
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        exportNonEmployeeRecords: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('exportNonEmployeeRecords', 'id', id);
		                            localVarPath = "/non-employee-sources/{id}/non-employees/download"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This requests a download for the Source Schema Template for a provided source. Request will require the following security scope: idn:nesr:read\'
		         * @summary Exports Source Schema Template
		         * @param {string} id Source Id (UUID)
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        exportNonEmployeeSourceSchemaTemplate: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('exportNonEmployeeSourceSchemaTemplate', 'id', id);
		                            localVarPath = "/non-employee-sources/{id}/schema-attributes-template/download"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Approves a non-employee approval request and notifies the next approver.
		         * @summary Get a non-employee approval item detail
		         * @param {string} id Non-Employee approval item id (UUID)
		         * @param {string} [includeDetail] The object nonEmployeeRequest will not be included detail when set to false. *Default value is true*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getNonEmployeeApproval: function (id, includeDetail, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getNonEmployeeApproval', 'id', id);
		                            localVarPath = "/non-employee-approvals/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (includeDetail !== undefined) {
		                                localVarQueryParameter['include-detail'] = includeDetail;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This request will retrieve a summary of non-employee approval requests. There are two contextual uses for the `requested-for` path parameter: 1. The current user is the Org Admin, in which case he or she may request a summary of all non-employee approval requests assigned to a particular approver by passing in that approver\'s id. 2. The current user is an approver, in which case \"me\" should be provided as the `requested-for` value. This will provide the approver with a summary of the approval items assigned to him or her.
		         * @summary Get Summary of Non-Employee Approval Requests
		         * @param {string} requestedFor The identity (UUID) of the approver for whom for whom the summary is being retrieved. Use \&quot;me\&quot; instead to indicate the current user.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getNonEmployeeApprovalSummary: function (requestedFor, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'requestedFor' is not null or undefined
		                            (0, common_1.assertParamExists)('getNonEmployeeApprovalSummary', 'requestedFor', requestedFor);
		                            localVarPath = "/non-employee-approvals/summary/{requested-for}"
		                                .replace("{".concat("requested-for", "}"), encodeURIComponent(String(requestedFor)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * The nonEmployeeBulkUploadStatus API returns the status of the newest bulk upload job for the specified source.
		         * @summary Bulk upload status on source
		         * @param {string} id Source ID (UUID)
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getNonEmployeeBulkUploadStatus: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getNonEmployeeBulkUploadStatus', 'id', id);
		                            localVarPath = "/non-employee-sources/{id}/non-employee-bulk-upload/status"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets a non-employee record.
		         * @summary Get a Non-Employee Record
		         * @param {string} id Non-Employee record id (UUID)
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getNonEmployeeRecord: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getNonEmployeeRecord', 'id', id);
		                            localVarPath = "/non-employee-records/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets a non-employee request.
		         * @summary Get a Non-Employee Request
		         * @param {string} id Non-Employee request id (UUID)
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getNonEmployeeRequest: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getNonEmployeeRequest', 'id', id);
		                            localVarPath = "/non-employee-requests/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This request will retrieve a summary of non-employee requests. There are two contextual uses for the `requested-for` path parameter: 1. The current user is the Org Admin, in which case he or she may request a summary of all non-employee approval requests assigned to a particular account manager by passing in that manager\'s id. 2. The current user is an account manager, in which case \"me\" should be provided as the `requested-for` value. This will provide the user with a summary of the non-employee requests in the source(s) he or she manages.
		         * @summary Get Summary of Non-Employee Requests
		         * @param {string} requestedFor The identity (UUID) of the non-employee account manager for whom the summary is being retrieved. Use \&quot;me\&quot; instead to indicate the current user.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getNonEmployeeRequestSummary: function (requestedFor, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'requestedFor' is not null or undefined
		                            (0, common_1.assertParamExists)('getNonEmployeeRequestSummary', 'requestedFor', requestedFor);
		                            localVarPath = "/non-employee-requests/summary/{requested-for}"
		                                .replace("{".concat("requested-for", "}"), encodeURIComponent(String(requestedFor)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API gets a schema attribute by Id for the specified Non-Employee SourceId.
		         * @summary Get Schema Attribute Non-Employee Source
		         * @param {string} attributeId The Schema Attribute Id (UUID)
		         * @param {string} sourceId The Source id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getNonEmployeeSchemaAttribute: function (attributeId, sourceId, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'attributeId' is not null or undefined
		                            (0, common_1.assertParamExists)('getNonEmployeeSchemaAttribute', 'attributeId', attributeId);
		                            // verify required parameter 'sourceId' is not null or undefined
		                            (0, common_1.assertParamExists)('getNonEmployeeSchemaAttribute', 'sourceId', sourceId);
		                            localVarPath = "/non-employee-sources/{sourceId}/schema-attributes/{attributeId}"
		                                .replace("{".concat("attributeId", "}"), encodeURIComponent(String(attributeId)))
		                                .replace("{".concat("sourceId", "}"), encodeURIComponent(String(sourceId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets a non-employee source.
		         * @summary Get a Non-Employee Source
		         * @param {string} sourceId Source Id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getNonEmployeeSource: function (sourceId, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'sourceId' is not null or undefined
		                            (0, common_1.assertParamExists)('getNonEmployeeSource', 'sourceId', sourceId);
		                            localVarPath = "/non-employee-sources/{sourceId}"
		                                .replace("{".concat("sourceId", "}"), encodeURIComponent(String(sourceId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API gets the list of schema attributes for the specified Non-Employee SourceId. There are 8 mandatory attributes added to each new Non-Employee Source automatically. Additionaly, user can add up to 10 custom attributes. This interface returns all the mandatory attributes followed by any custom attributes. At most, a total of 18 attributes will be returned.
		         * @summary List Schema Attributes Non-Employee Source
		         * @param {string} sourceId The Source id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getNonEmployeeSourceSchemaAttributes: function (sourceId, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'sourceId' is not null or undefined
		                            (0, common_1.assertParamExists)('getNonEmployeeSourceSchemaAttributes', 'sourceId', sourceId);
		                            localVarPath = "/non-employee-sources/{sourceId}/schema-attributes"
		                                .replace("{".concat("sourceId", "}"), encodeURIComponent(String(sourceId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This post will import, or update, Non-Employee records found in the CSV. Request will need the following security scope: \'idn:nesr:create\'
		         * @summary Imports, or Updates, Non-Employee Records
		         * @param {string} id Source Id (UUID)
		         * @param {any} data
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        importNonEmployeeRecordsInBulk: function (id, data, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, localVarFormParams, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('importNonEmployeeRecordsInBulk', 'id', id);
		                            // verify required parameter 'data' is not null or undefined
		                            (0, common_1.assertParamExists)('importNonEmployeeRecordsInBulk', 'data', data);
		                            localVarPath = "/non-employee-sources/{id}/non-employee-bulk-upload"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            localVarFormParams = new ((configuration && configuration.formDataCtor) || FormData)();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (data !== undefined) {
		                                localVarFormParams.append('data', data);
		                            }
		                            localVarHeaderParameter['Content-Type'] = 'multipart/form-data';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = localVarFormParams;
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets a list of non-employee approval requests.
		         * @summary Get List of Non-Employee Approval Requests
		         * @param {string} [requestedFor] The identity for whom the request was made. *me* indicates the current user.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **approvalStatus**: *eq*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **created, modified**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listNonEmployeeApproval: function (requestedFor, limit, offset, count, filters, sorters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/non-employee-approvals";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (requestedFor !== undefined) {
		                                localVarQueryParameter['requested-for'] = requestedFor;
		                            }
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets a list of non-employee records.
		         * @summary List Non-Employee Records
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **id, accountName, sourceId, manager, firstName, lastName, email, phone, startDate, endDate, created, modified**
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **sourceId**: *eq*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listNonEmployeeRecords: function (limit, offset, count, sorters, filters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/non-employee-records";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets a list of non-employee requests.
		         * @summary List Non-Employee Requests
		         * @param {string} requestedFor The identity for whom the request was made. *me* indicates the current user.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **created, approvalStatus, firstName, lastName, email, phone, accountName, startDate, endDate**
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **sourceId**: *eq*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listNonEmployeeRequests: function (requestedFor, limit, offset, count, sorters, filters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'requestedFor' is not null or undefined
		                            (0, common_1.assertParamExists)('listNonEmployeeRequests', 'requestedFor', requestedFor);
		                            localVarPath = "/non-employee-requests";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (requestedFor !== undefined) {
		                                localVarQueryParameter['requested-for'] = requestedFor;
		                            }
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets a list of non-employee sources.
		         * @summary List Non-Employee Sources
		         * @param {string} requestedFor The identity for whom the request was made. *me* indicates the current user.
		         * @param {boolean} nonEmployeeCount The flag to determine whether return a non-employee count associate with source.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name, created, sourceId**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listNonEmployeeSources: function (requestedFor, nonEmployeeCount, limit, offset, count, sorters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'requestedFor' is not null or undefined
		                            (0, common_1.assertParamExists)('listNonEmployeeSources', 'requestedFor', requestedFor);
		                            // verify required parameter 'nonEmployeeCount' is not null or undefined
		                            (0, common_1.assertParamExists)('listNonEmployeeSources', 'nonEmployeeCount', nonEmployeeCount);
		                            localVarPath = "/non-employee-sources";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (requestedFor !== undefined) {
		                                localVarQueryParameter['requested-for'] = requestedFor;
		                            }
		                            if (nonEmployeeCount !== undefined) {
		                                localVarQueryParameter['non-employee-count'] = nonEmployeeCount;
		                            }
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This request will patch a non-employee record.
		         * @summary Patch Non-Employee Record
		         * @param {string} id Non-employee record id (UUID)
		         * @param {Array<JsonPatchOperationBeta>} jsonPatchOperationBeta A list of non-employee update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard. Attributes are restricted by user type. Owner of source can update end date. Organization admins can update all available fields.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchNonEmployeeRecord: function (id, jsonPatchOperationBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('patchNonEmployeeRecord', 'id', id);
		                            // verify required parameter 'jsonPatchOperationBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('patchNonEmployeeRecord', 'jsonPatchOperationBeta', jsonPatchOperationBeta);
		                            localVarPath = "/non-employee-records/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PATCH' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json-patch+json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(jsonPatchOperationBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This end-point patches a specific schema attribute for a non-employee SourceId.
		         * @summary Patch Non-Employee Source\'s Schema Attribute
		         * @param {string} attributeId The Schema Attribute Id (UUID)
		         * @param {string} sourceId The Source id
		         * @param {Array<JsonPatchOperationBeta>} jsonPatchOperationBeta A list of schema attribute update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard. The following properties are allowed for update \&#39;:\&#39; \&#39;label\&#39;, \&#39;helpText\&#39;, \&#39;placeholder\&#39;, \&#39;required\&#39;.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchNonEmployeeSchemaAttribute: function (attributeId, sourceId, jsonPatchOperationBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'attributeId' is not null or undefined
		                            (0, common_1.assertParamExists)('patchNonEmployeeSchemaAttribute', 'attributeId', attributeId);
		                            // verify required parameter 'sourceId' is not null or undefined
		                            (0, common_1.assertParamExists)('patchNonEmployeeSchemaAttribute', 'sourceId', sourceId);
		                            // verify required parameter 'jsonPatchOperationBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('patchNonEmployeeSchemaAttribute', 'jsonPatchOperationBeta', jsonPatchOperationBeta);
		                            localVarPath = "/non-employee-sources/{sourceId}/schema-attributes/{attributeId}"
		                                .replace("{".concat("attributeId", "}"), encodeURIComponent(String(attributeId)))
		                                .replace("{".concat("sourceId", "}"), encodeURIComponent(String(sourceId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PATCH' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json-patch+json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(jsonPatchOperationBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * patch a non-employee source. (Partial Update)  Patchable field: **name, description, approvers, accountManagers**
		         * @summary Patch a Non-Employee Source
		         * @param {string} sourceId Source Id
		         * @param {Array<JsonPatchOperationBeta>} jsonPatchOperationBeta A list of non-employee source update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchNonEmployeeSource: function (sourceId, jsonPatchOperationBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'sourceId' is not null or undefined
		                            (0, common_1.assertParamExists)('patchNonEmployeeSource', 'sourceId', sourceId);
		                            // verify required parameter 'jsonPatchOperationBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('patchNonEmployeeSource', 'jsonPatchOperationBeta', jsonPatchOperationBeta);
		                            localVarPath = "/non-employee-sources/{sourceId}"
		                                .replace("{".concat("sourceId", "}"), encodeURIComponent(String(sourceId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PATCH' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json-patch+json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(jsonPatchOperationBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This endpoint will reject an approval item request and notify user.
		         * @summary Reject a Non-Employee Request
		         * @param {string} id Non-Employee approval item id (UUID)
		         * @param {NonEmployeeRejectApprovalDecisionBeta} nonEmployeeRejectApprovalDecisionBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        rejectNonEmployeeRequest: function (id, nonEmployeeRejectApprovalDecisionBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('rejectNonEmployeeRequest', 'id', id);
		                            // verify required parameter 'nonEmployeeRejectApprovalDecisionBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('rejectNonEmployeeRequest', 'nonEmployeeRejectApprovalDecisionBeta', nonEmployeeRejectApprovalDecisionBeta);
		                            localVarPath = "/non-employee-approvals/{id}/reject"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(nonEmployeeRejectApprovalDecisionBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This request will update a non-employee record.
		         * @summary Update Non-Employee Record
		         * @param {string} id Non-employee record id (UUID)
		         * @param {NonEmployeeRequestBodyBeta} nonEmployeeRequestBodyBeta Non-employee record creation request body. Attributes are restricted by user type. Owner of source can update end date. Organization admins can update all available fields.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateNonEmployeeRecord: function (id, nonEmployeeRequestBodyBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('updateNonEmployeeRecord', 'id', id);
		                            // verify required parameter 'nonEmployeeRequestBodyBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('updateNonEmployeeRecord', 'nonEmployeeRequestBodyBeta', nonEmployeeRequestBodyBeta);
		                            localVarPath = "/non-employee-records/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PUT' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(nonEmployeeRequestBodyBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.NonEmployeeLifecycleManagementBetaApiAxiosParamCreator = NonEmployeeLifecycleManagementBetaApiAxiosParamCreator;
		/**
		 * NonEmployeeLifecycleManagementBetaApi - functional programming interface
		 * @export
		 */
		var NonEmployeeLifecycleManagementBetaApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.NonEmployeeLifecycleManagementBetaApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * Approves a non-employee approval request and notifies the next approver.
		         * @summary Approve a Non-Employee Request
		         * @param {string} id Non-Employee approval item id (UUID)
		         * @param {NonEmployeeApprovalDecisionBeta} nonEmployeeApprovalDecisionBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        approveNonEmployeeRequest: function (id, nonEmployeeApprovalDecisionBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.approveNonEmployeeRequest(id, nonEmployeeApprovalDecisionBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This request will create a non-employee record. Request will require the following security scope: \'idn:nesr:create\'
		         * @summary Create Non-Employee Record
		         * @param {NonEmployeeRequestBodyBeta} nonEmployeeRequestBodyBeta Non-Employee record creation request body.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createNonEmployeeRecord: function (nonEmployeeRequestBodyBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.createNonEmployeeRecord(nonEmployeeRequestBodyBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This request will create a non-employee request and notify the approver
		         * @summary Create Non-Employee Request
		         * @param {NonEmployeeRequestBodyBeta} nonEmployeeRequestBodyBeta Non-Employee creation request body
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createNonEmployeeRequest: function (nonEmployeeRequestBodyBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.createNonEmployeeRequest(nonEmployeeRequestBodyBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This request will create a non-employee source. Request will require the following security scope: \'idn:nesr:create\'
		         * @summary Create Non-Employee Source
		         * @param {NonEmployeeSourceRequestBodyBeta} nonEmployeeSourceRequestBodyBeta Non-Employee source creation request body.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createNonEmployeeSource: function (nonEmployeeSourceRequestBodyBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.createNonEmployeeSource(nonEmployeeSourceRequestBodyBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API creates a new schema attribute for Non-Employee Source. The schema technical name must be unique in the source. Attempts to create a schema attribute with an existing name will result in a \"400.1.409 Reference conflict\" response. At most, 10 custom attributes can be created per schema. Attempts to create more than 10 will result in a \"400.1.4 Limit violation\" response.
		         * @summary Create Non-Employee Source Schema Attribute
		         * @param {string} sourceId The Source id
		         * @param {NonEmployeeSchemaAttributeBodyBeta} nonEmployeeSchemaAttributeBodyBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createNonEmployeeSourceSchemaAttributes: function (sourceId, nonEmployeeSchemaAttributeBodyBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.createNonEmployeeSourceSchemaAttributes(sourceId, nonEmployeeSchemaAttributeBodyBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This request will delete a non-employee record.
		         * @summary Delete Non-Employee Record
		         * @param {string} id Non-Employee record id (UUID)
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteNonEmployeeRecord: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.deleteNonEmployeeRecord(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This request will delete multiple non-employee records based on the non-employee ids provided. Request will require the following scope: \'idn:nesr:delete\'
		         * @summary Delete Multiple Non-Employee Records
		         * @param {DeleteNonEmployeeRecordInBulkRequestBeta} deleteNonEmployeeRecordInBulkRequestBeta Non-Employee bulk delete request body.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteNonEmployeeRecordInBulk: function (deleteNonEmployeeRecordInBulkRequestBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.deleteNonEmployeeRecordInBulk(deleteNonEmployeeRecordInBulkRequestBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This request will delete a non-employee request.
		         * @summary Delete Non-Employee Request
		         * @param {string} id Non-Employee request id in the UUID format
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteNonEmployeeRequest: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.deleteNonEmployeeRequest(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This end-point deletes a specific schema attribute for a non-employee source.
		         * @summary Delete Non-Employee Source\'s Schema Attribute
		         * @param {string} attributeId The Schema Attribute Id (UUID)
		         * @param {string} sourceId The Source id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteNonEmployeeSchemaAttribute: function (attributeId, sourceId, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.deleteNonEmployeeSchemaAttribute(attributeId, sourceId, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This request will delete a non-employee source.
		         * @summary Delete Non-Employee Source
		         * @param {string} sourceId Source Id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteNonEmployeeSource: function (sourceId, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.deleteNonEmployeeSource(sourceId, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This end-point deletes all custom schema attributes for a non-employee source.
		         * @summary Delete all custom schema attributes
		         * @param {string} sourceId The Source id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteNonEmployeeSourceSchemaAttributes: function (sourceId, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.deleteNonEmployeeSourceSchemaAttributes(sourceId, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This requests a CSV download for all non-employees from a provided source.
		         * @summary Exports Non-Employee Records to CSV
		         * @param {string} id Source Id (UUID)
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        exportNonEmployeeRecords: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.exportNonEmployeeRecords(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This requests a download for the Source Schema Template for a provided source. Request will require the following security scope: idn:nesr:read\'
		         * @summary Exports Source Schema Template
		         * @param {string} id Source Id (UUID)
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        exportNonEmployeeSourceSchemaTemplate: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.exportNonEmployeeSourceSchemaTemplate(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Approves a non-employee approval request and notifies the next approver.
		         * @summary Get a non-employee approval item detail
		         * @param {string} id Non-Employee approval item id (UUID)
		         * @param {string} [includeDetail] The object nonEmployeeRequest will not be included detail when set to false. *Default value is true*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getNonEmployeeApproval: function (id, includeDetail, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getNonEmployeeApproval(id, includeDetail, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This request will retrieve a summary of non-employee approval requests. There are two contextual uses for the `requested-for` path parameter: 1. The current user is the Org Admin, in which case he or she may request a summary of all non-employee approval requests assigned to a particular approver by passing in that approver\'s id. 2. The current user is an approver, in which case \"me\" should be provided as the `requested-for` value. This will provide the approver with a summary of the approval items assigned to him or her.
		         * @summary Get Summary of Non-Employee Approval Requests
		         * @param {string} requestedFor The identity (UUID) of the approver for whom for whom the summary is being retrieved. Use \&quot;me\&quot; instead to indicate the current user.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getNonEmployeeApprovalSummary: function (requestedFor, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getNonEmployeeApprovalSummary(requestedFor, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * The nonEmployeeBulkUploadStatus API returns the status of the newest bulk upload job for the specified source.
		         * @summary Bulk upload status on source
		         * @param {string} id Source ID (UUID)
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getNonEmployeeBulkUploadStatus: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getNonEmployeeBulkUploadStatus(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets a non-employee record.
		         * @summary Get a Non-Employee Record
		         * @param {string} id Non-Employee record id (UUID)
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getNonEmployeeRecord: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getNonEmployeeRecord(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets a non-employee request.
		         * @summary Get a Non-Employee Request
		         * @param {string} id Non-Employee request id (UUID)
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getNonEmployeeRequest: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getNonEmployeeRequest(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This request will retrieve a summary of non-employee requests. There are two contextual uses for the `requested-for` path parameter: 1. The current user is the Org Admin, in which case he or she may request a summary of all non-employee approval requests assigned to a particular account manager by passing in that manager\'s id. 2. The current user is an account manager, in which case \"me\" should be provided as the `requested-for` value. This will provide the user with a summary of the non-employee requests in the source(s) he or she manages.
		         * @summary Get Summary of Non-Employee Requests
		         * @param {string} requestedFor The identity (UUID) of the non-employee account manager for whom the summary is being retrieved. Use \&quot;me\&quot; instead to indicate the current user.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getNonEmployeeRequestSummary: function (requestedFor, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getNonEmployeeRequestSummary(requestedFor, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API gets a schema attribute by Id for the specified Non-Employee SourceId.
		         * @summary Get Schema Attribute Non-Employee Source
		         * @param {string} attributeId The Schema Attribute Id (UUID)
		         * @param {string} sourceId The Source id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getNonEmployeeSchemaAttribute: function (attributeId, sourceId, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getNonEmployeeSchemaAttribute(attributeId, sourceId, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets a non-employee source.
		         * @summary Get a Non-Employee Source
		         * @param {string} sourceId Source Id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getNonEmployeeSource: function (sourceId, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getNonEmployeeSource(sourceId, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API gets the list of schema attributes for the specified Non-Employee SourceId. There are 8 mandatory attributes added to each new Non-Employee Source automatically. Additionaly, user can add up to 10 custom attributes. This interface returns all the mandatory attributes followed by any custom attributes. At most, a total of 18 attributes will be returned.
		         * @summary List Schema Attributes Non-Employee Source
		         * @param {string} sourceId The Source id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getNonEmployeeSourceSchemaAttributes: function (sourceId, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getNonEmployeeSourceSchemaAttributes(sourceId, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This post will import, or update, Non-Employee records found in the CSV. Request will need the following security scope: \'idn:nesr:create\'
		         * @summary Imports, or Updates, Non-Employee Records
		         * @param {string} id Source Id (UUID)
		         * @param {any} data
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        importNonEmployeeRecordsInBulk: function (id, data, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.importNonEmployeeRecordsInBulk(id, data, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets a list of non-employee approval requests.
		         * @summary Get List of Non-Employee Approval Requests
		         * @param {string} [requestedFor] The identity for whom the request was made. *me* indicates the current user.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **approvalStatus**: *eq*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **created, modified**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listNonEmployeeApproval: function (requestedFor, limit, offset, count, filters, sorters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listNonEmployeeApproval(requestedFor, limit, offset, count, filters, sorters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets a list of non-employee records.
		         * @summary List Non-Employee Records
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **id, accountName, sourceId, manager, firstName, lastName, email, phone, startDate, endDate, created, modified**
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **sourceId**: *eq*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listNonEmployeeRecords: function (limit, offset, count, sorters, filters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listNonEmployeeRecords(limit, offset, count, sorters, filters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets a list of non-employee requests.
		         * @summary List Non-Employee Requests
		         * @param {string} requestedFor The identity for whom the request was made. *me* indicates the current user.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **created, approvalStatus, firstName, lastName, email, phone, accountName, startDate, endDate**
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **sourceId**: *eq*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listNonEmployeeRequests: function (requestedFor, limit, offset, count, sorters, filters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listNonEmployeeRequests(requestedFor, limit, offset, count, sorters, filters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets a list of non-employee sources.
		         * @summary List Non-Employee Sources
		         * @param {string} requestedFor The identity for whom the request was made. *me* indicates the current user.
		         * @param {boolean} nonEmployeeCount The flag to determine whether return a non-employee count associate with source.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name, created, sourceId**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listNonEmployeeSources: function (requestedFor, nonEmployeeCount, limit, offset, count, sorters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listNonEmployeeSources(requestedFor, nonEmployeeCount, limit, offset, count, sorters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This request will patch a non-employee record.
		         * @summary Patch Non-Employee Record
		         * @param {string} id Non-employee record id (UUID)
		         * @param {Array<JsonPatchOperationBeta>} jsonPatchOperationBeta A list of non-employee update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard. Attributes are restricted by user type. Owner of source can update end date. Organization admins can update all available fields.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchNonEmployeeRecord: function (id, jsonPatchOperationBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.patchNonEmployeeRecord(id, jsonPatchOperationBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This end-point patches a specific schema attribute for a non-employee SourceId.
		         * @summary Patch Non-Employee Source\'s Schema Attribute
		         * @param {string} attributeId The Schema Attribute Id (UUID)
		         * @param {string} sourceId The Source id
		         * @param {Array<JsonPatchOperationBeta>} jsonPatchOperationBeta A list of schema attribute update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard. The following properties are allowed for update \&#39;:\&#39; \&#39;label\&#39;, \&#39;helpText\&#39;, \&#39;placeholder\&#39;, \&#39;required\&#39;.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchNonEmployeeSchemaAttribute: function (attributeId, sourceId, jsonPatchOperationBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.patchNonEmployeeSchemaAttribute(attributeId, sourceId, jsonPatchOperationBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * patch a non-employee source. (Partial Update)  Patchable field: **name, description, approvers, accountManagers**
		         * @summary Patch a Non-Employee Source
		         * @param {string} sourceId Source Id
		         * @param {Array<JsonPatchOperationBeta>} jsonPatchOperationBeta A list of non-employee source update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchNonEmployeeSource: function (sourceId, jsonPatchOperationBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.patchNonEmployeeSource(sourceId, jsonPatchOperationBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This endpoint will reject an approval item request and notify user.
		         * @summary Reject a Non-Employee Request
		         * @param {string} id Non-Employee approval item id (UUID)
		         * @param {NonEmployeeRejectApprovalDecisionBeta} nonEmployeeRejectApprovalDecisionBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        rejectNonEmployeeRequest: function (id, nonEmployeeRejectApprovalDecisionBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.rejectNonEmployeeRequest(id, nonEmployeeRejectApprovalDecisionBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This request will update a non-employee record.
		         * @summary Update Non-Employee Record
		         * @param {string} id Non-employee record id (UUID)
		         * @param {NonEmployeeRequestBodyBeta} nonEmployeeRequestBodyBeta Non-employee record creation request body. Attributes are restricted by user type. Owner of source can update end date. Organization admins can update all available fields.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateNonEmployeeRecord: function (id, nonEmployeeRequestBodyBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.updateNonEmployeeRecord(id, nonEmployeeRequestBodyBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.NonEmployeeLifecycleManagementBetaApiFp = NonEmployeeLifecycleManagementBetaApiFp;
		/**
		 * NonEmployeeLifecycleManagementBetaApi - factory interface
		 * @export
		 */
		var NonEmployeeLifecycleManagementBetaApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.NonEmployeeLifecycleManagementBetaApiFp)(configuration);
		    return {
		        /**
		         * Approves a non-employee approval request and notifies the next approver.
		         * @summary Approve a Non-Employee Request
		         * @param {string} id Non-Employee approval item id (UUID)
		         * @param {NonEmployeeApprovalDecisionBeta} nonEmployeeApprovalDecisionBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        approveNonEmployeeRequest: function (id, nonEmployeeApprovalDecisionBeta, axiosOptions) {
		            return localVarFp.approveNonEmployeeRequest(id, nonEmployeeApprovalDecisionBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This request will create a non-employee record. Request will require the following security scope: \'idn:nesr:create\'
		         * @summary Create Non-Employee Record
		         * @param {NonEmployeeRequestBodyBeta} nonEmployeeRequestBodyBeta Non-Employee record creation request body.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createNonEmployeeRecord: function (nonEmployeeRequestBodyBeta, axiosOptions) {
		            return localVarFp.createNonEmployeeRecord(nonEmployeeRequestBodyBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This request will create a non-employee request and notify the approver
		         * @summary Create Non-Employee Request
		         * @param {NonEmployeeRequestBodyBeta} nonEmployeeRequestBodyBeta Non-Employee creation request body
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createNonEmployeeRequest: function (nonEmployeeRequestBodyBeta, axiosOptions) {
		            return localVarFp.createNonEmployeeRequest(nonEmployeeRequestBodyBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This request will create a non-employee source. Request will require the following security scope: \'idn:nesr:create\'
		         * @summary Create Non-Employee Source
		         * @param {NonEmployeeSourceRequestBodyBeta} nonEmployeeSourceRequestBodyBeta Non-Employee source creation request body.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createNonEmployeeSource: function (nonEmployeeSourceRequestBodyBeta, axiosOptions) {
		            return localVarFp.createNonEmployeeSource(nonEmployeeSourceRequestBodyBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API creates a new schema attribute for Non-Employee Source. The schema technical name must be unique in the source. Attempts to create a schema attribute with an existing name will result in a \"400.1.409 Reference conflict\" response. At most, 10 custom attributes can be created per schema. Attempts to create more than 10 will result in a \"400.1.4 Limit violation\" response.
		         * @summary Create Non-Employee Source Schema Attribute
		         * @param {string} sourceId The Source id
		         * @param {NonEmployeeSchemaAttributeBodyBeta} nonEmployeeSchemaAttributeBodyBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createNonEmployeeSourceSchemaAttributes: function (sourceId, nonEmployeeSchemaAttributeBodyBeta, axiosOptions) {
		            return localVarFp.createNonEmployeeSourceSchemaAttributes(sourceId, nonEmployeeSchemaAttributeBodyBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This request will delete a non-employee record.
		         * @summary Delete Non-Employee Record
		         * @param {string} id Non-Employee record id (UUID)
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteNonEmployeeRecord: function (id, axiosOptions) {
		            return localVarFp.deleteNonEmployeeRecord(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This request will delete multiple non-employee records based on the non-employee ids provided. Request will require the following scope: \'idn:nesr:delete\'
		         * @summary Delete Multiple Non-Employee Records
		         * @param {DeleteNonEmployeeRecordInBulkRequestBeta} deleteNonEmployeeRecordInBulkRequestBeta Non-Employee bulk delete request body.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteNonEmployeeRecordInBulk: function (deleteNonEmployeeRecordInBulkRequestBeta, axiosOptions) {
		            return localVarFp.deleteNonEmployeeRecordInBulk(deleteNonEmployeeRecordInBulkRequestBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This request will delete a non-employee request.
		         * @summary Delete Non-Employee Request
		         * @param {string} id Non-Employee request id in the UUID format
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteNonEmployeeRequest: function (id, axiosOptions) {
		            return localVarFp.deleteNonEmployeeRequest(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This end-point deletes a specific schema attribute for a non-employee source.
		         * @summary Delete Non-Employee Source\'s Schema Attribute
		         * @param {string} attributeId The Schema Attribute Id (UUID)
		         * @param {string} sourceId The Source id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteNonEmployeeSchemaAttribute: function (attributeId, sourceId, axiosOptions) {
		            return localVarFp.deleteNonEmployeeSchemaAttribute(attributeId, sourceId, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This request will delete a non-employee source.
		         * @summary Delete Non-Employee Source
		         * @param {string} sourceId Source Id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteNonEmployeeSource: function (sourceId, axiosOptions) {
		            return localVarFp.deleteNonEmployeeSource(sourceId, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This end-point deletes all custom schema attributes for a non-employee source.
		         * @summary Delete all custom schema attributes
		         * @param {string} sourceId The Source id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteNonEmployeeSourceSchemaAttributes: function (sourceId, axiosOptions) {
		            return localVarFp.deleteNonEmployeeSourceSchemaAttributes(sourceId, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This requests a CSV download for all non-employees from a provided source.
		         * @summary Exports Non-Employee Records to CSV
		         * @param {string} id Source Id (UUID)
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        exportNonEmployeeRecords: function (id, axiosOptions) {
		            return localVarFp.exportNonEmployeeRecords(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This requests a download for the Source Schema Template for a provided source. Request will require the following security scope: idn:nesr:read\'
		         * @summary Exports Source Schema Template
		         * @param {string} id Source Id (UUID)
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        exportNonEmployeeSourceSchemaTemplate: function (id, axiosOptions) {
		            return localVarFp.exportNonEmployeeSourceSchemaTemplate(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Approves a non-employee approval request and notifies the next approver.
		         * @summary Get a non-employee approval item detail
		         * @param {string} id Non-Employee approval item id (UUID)
		         * @param {string} [includeDetail] The object nonEmployeeRequest will not be included detail when set to false. *Default value is true*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getNonEmployeeApproval: function (id, includeDetail, axiosOptions) {
		            return localVarFp.getNonEmployeeApproval(id, includeDetail, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This request will retrieve a summary of non-employee approval requests. There are two contextual uses for the `requested-for` path parameter: 1. The current user is the Org Admin, in which case he or she may request a summary of all non-employee approval requests assigned to a particular approver by passing in that approver\'s id. 2. The current user is an approver, in which case \"me\" should be provided as the `requested-for` value. This will provide the approver with a summary of the approval items assigned to him or her.
		         * @summary Get Summary of Non-Employee Approval Requests
		         * @param {string} requestedFor The identity (UUID) of the approver for whom for whom the summary is being retrieved. Use \&quot;me\&quot; instead to indicate the current user.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getNonEmployeeApprovalSummary: function (requestedFor, axiosOptions) {
		            return localVarFp.getNonEmployeeApprovalSummary(requestedFor, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * The nonEmployeeBulkUploadStatus API returns the status of the newest bulk upload job for the specified source.
		         * @summary Bulk upload status on source
		         * @param {string} id Source ID (UUID)
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getNonEmployeeBulkUploadStatus: function (id, axiosOptions) {
		            return localVarFp.getNonEmployeeBulkUploadStatus(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This gets a non-employee record.
		         * @summary Get a Non-Employee Record
		         * @param {string} id Non-Employee record id (UUID)
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getNonEmployeeRecord: function (id, axiosOptions) {
		            return localVarFp.getNonEmployeeRecord(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This gets a non-employee request.
		         * @summary Get a Non-Employee Request
		         * @param {string} id Non-Employee request id (UUID)
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getNonEmployeeRequest: function (id, axiosOptions) {
		            return localVarFp.getNonEmployeeRequest(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This request will retrieve a summary of non-employee requests. There are two contextual uses for the `requested-for` path parameter: 1. The current user is the Org Admin, in which case he or she may request a summary of all non-employee approval requests assigned to a particular account manager by passing in that manager\'s id. 2. The current user is an account manager, in which case \"me\" should be provided as the `requested-for` value. This will provide the user with a summary of the non-employee requests in the source(s) he or she manages.
		         * @summary Get Summary of Non-Employee Requests
		         * @param {string} requestedFor The identity (UUID) of the non-employee account manager for whom the summary is being retrieved. Use \&quot;me\&quot; instead to indicate the current user.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getNonEmployeeRequestSummary: function (requestedFor, axiosOptions) {
		            return localVarFp.getNonEmployeeRequestSummary(requestedFor, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API gets a schema attribute by Id for the specified Non-Employee SourceId.
		         * @summary Get Schema Attribute Non-Employee Source
		         * @param {string} attributeId The Schema Attribute Id (UUID)
		         * @param {string} sourceId The Source id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getNonEmployeeSchemaAttribute: function (attributeId, sourceId, axiosOptions) {
		            return localVarFp.getNonEmployeeSchemaAttribute(attributeId, sourceId, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This gets a non-employee source.
		         * @summary Get a Non-Employee Source
		         * @param {string} sourceId Source Id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getNonEmployeeSource: function (sourceId, axiosOptions) {
		            return localVarFp.getNonEmployeeSource(sourceId, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API gets the list of schema attributes for the specified Non-Employee SourceId. There are 8 mandatory attributes added to each new Non-Employee Source automatically. Additionaly, user can add up to 10 custom attributes. This interface returns all the mandatory attributes followed by any custom attributes. At most, a total of 18 attributes will be returned.
		         * @summary List Schema Attributes Non-Employee Source
		         * @param {string} sourceId The Source id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getNonEmployeeSourceSchemaAttributes: function (sourceId, axiosOptions) {
		            return localVarFp.getNonEmployeeSourceSchemaAttributes(sourceId, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This post will import, or update, Non-Employee records found in the CSV. Request will need the following security scope: \'idn:nesr:create\'
		         * @summary Imports, or Updates, Non-Employee Records
		         * @param {string} id Source Id (UUID)
		         * @param {any} data
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        importNonEmployeeRecordsInBulk: function (id, data, axiosOptions) {
		            return localVarFp.importNonEmployeeRecordsInBulk(id, data, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This gets a list of non-employee approval requests.
		         * @summary Get List of Non-Employee Approval Requests
		         * @param {string} [requestedFor] The identity for whom the request was made. *me* indicates the current user.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **approvalStatus**: *eq*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **created, modified**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listNonEmployeeApproval: function (requestedFor, limit, offset, count, filters, sorters, axiosOptions) {
		            return localVarFp.listNonEmployeeApproval(requestedFor, limit, offset, count, filters, sorters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This gets a list of non-employee records.
		         * @summary List Non-Employee Records
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **id, accountName, sourceId, manager, firstName, lastName, email, phone, startDate, endDate, created, modified**
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **sourceId**: *eq*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listNonEmployeeRecords: function (limit, offset, count, sorters, filters, axiosOptions) {
		            return localVarFp.listNonEmployeeRecords(limit, offset, count, sorters, filters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This gets a list of non-employee requests.
		         * @summary List Non-Employee Requests
		         * @param {string} requestedFor The identity for whom the request was made. *me* indicates the current user.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **created, approvalStatus, firstName, lastName, email, phone, accountName, startDate, endDate**
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **sourceId**: *eq*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listNonEmployeeRequests: function (requestedFor, limit, offset, count, sorters, filters, axiosOptions) {
		            return localVarFp.listNonEmployeeRequests(requestedFor, limit, offset, count, sorters, filters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This gets a list of non-employee sources.
		         * @summary List Non-Employee Sources
		         * @param {string} requestedFor The identity for whom the request was made. *me* indicates the current user.
		         * @param {boolean} nonEmployeeCount The flag to determine whether return a non-employee count associate with source.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name, created, sourceId**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listNonEmployeeSources: function (requestedFor, nonEmployeeCount, limit, offset, count, sorters, axiosOptions) {
		            return localVarFp.listNonEmployeeSources(requestedFor, nonEmployeeCount, limit, offset, count, sorters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This request will patch a non-employee record.
		         * @summary Patch Non-Employee Record
		         * @param {string} id Non-employee record id (UUID)
		         * @param {Array<JsonPatchOperationBeta>} jsonPatchOperationBeta A list of non-employee update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard. Attributes are restricted by user type. Owner of source can update end date. Organization admins can update all available fields.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchNonEmployeeRecord: function (id, jsonPatchOperationBeta, axiosOptions) {
		            return localVarFp.patchNonEmployeeRecord(id, jsonPatchOperationBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This end-point patches a specific schema attribute for a non-employee SourceId.
		         * @summary Patch Non-Employee Source\'s Schema Attribute
		         * @param {string} attributeId The Schema Attribute Id (UUID)
		         * @param {string} sourceId The Source id
		         * @param {Array<JsonPatchOperationBeta>} jsonPatchOperationBeta A list of schema attribute update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard. The following properties are allowed for update \&#39;:\&#39; \&#39;label\&#39;, \&#39;helpText\&#39;, \&#39;placeholder\&#39;, \&#39;required\&#39;.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchNonEmployeeSchemaAttribute: function (attributeId, sourceId, jsonPatchOperationBeta, axiosOptions) {
		            return localVarFp.patchNonEmployeeSchemaAttribute(attributeId, sourceId, jsonPatchOperationBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * patch a non-employee source. (Partial Update)  Patchable field: **name, description, approvers, accountManagers**
		         * @summary Patch a Non-Employee Source
		         * @param {string} sourceId Source Id
		         * @param {Array<JsonPatchOperationBeta>} jsonPatchOperationBeta A list of non-employee source update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchNonEmployeeSource: function (sourceId, jsonPatchOperationBeta, axiosOptions) {
		            return localVarFp.patchNonEmployeeSource(sourceId, jsonPatchOperationBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This endpoint will reject an approval item request and notify user.
		         * @summary Reject a Non-Employee Request
		         * @param {string} id Non-Employee approval item id (UUID)
		         * @param {NonEmployeeRejectApprovalDecisionBeta} nonEmployeeRejectApprovalDecisionBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        rejectNonEmployeeRequest: function (id, nonEmployeeRejectApprovalDecisionBeta, axiosOptions) {
		            return localVarFp.rejectNonEmployeeRequest(id, nonEmployeeRejectApprovalDecisionBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This request will update a non-employee record.
		         * @summary Update Non-Employee Record
		         * @param {string} id Non-employee record id (UUID)
		         * @param {NonEmployeeRequestBodyBeta} nonEmployeeRequestBodyBeta Non-employee record creation request body. Attributes are restricted by user type. Owner of source can update end date. Organization admins can update all available fields.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateNonEmployeeRecord: function (id, nonEmployeeRequestBodyBeta, axiosOptions) {
		            return localVarFp.updateNonEmployeeRecord(id, nonEmployeeRequestBodyBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.NonEmployeeLifecycleManagementBetaApiFactory = NonEmployeeLifecycleManagementBetaApiFactory;
		/**
		 * NonEmployeeLifecycleManagementBetaApi - object-oriented interface
		 * @export
		 * @class NonEmployeeLifecycleManagementBetaApi
		 * @extends {BaseAPI}
		 */
		var NonEmployeeLifecycleManagementBetaApi = /** @class */ (function (_super) {
		    __extends(NonEmployeeLifecycleManagementBetaApi, _super);
		    function NonEmployeeLifecycleManagementBetaApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * Approves a non-employee approval request and notifies the next approver.
		     * @summary Approve a Non-Employee Request
		     * @param {NonEmployeeLifecycleManagementBetaApiApproveNonEmployeeRequestRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof NonEmployeeLifecycleManagementBetaApi
		     */
		    NonEmployeeLifecycleManagementBetaApi.prototype.approveNonEmployeeRequest = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.NonEmployeeLifecycleManagementBetaApiFp)(this.configuration).approveNonEmployeeRequest(requestParameters.id, requestParameters.nonEmployeeApprovalDecisionBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This request will create a non-employee record. Request will require the following security scope: \'idn:nesr:create\'
		     * @summary Create Non-Employee Record
		     * @param {NonEmployeeLifecycleManagementBetaApiCreateNonEmployeeRecordRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof NonEmployeeLifecycleManagementBetaApi
		     */
		    NonEmployeeLifecycleManagementBetaApi.prototype.createNonEmployeeRecord = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.NonEmployeeLifecycleManagementBetaApiFp)(this.configuration).createNonEmployeeRecord(requestParameters.nonEmployeeRequestBodyBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This request will create a non-employee request and notify the approver
		     * @summary Create Non-Employee Request
		     * @param {NonEmployeeLifecycleManagementBetaApiCreateNonEmployeeRequestRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof NonEmployeeLifecycleManagementBetaApi
		     */
		    NonEmployeeLifecycleManagementBetaApi.prototype.createNonEmployeeRequest = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.NonEmployeeLifecycleManagementBetaApiFp)(this.configuration).createNonEmployeeRequest(requestParameters.nonEmployeeRequestBodyBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This request will create a non-employee source. Request will require the following security scope: \'idn:nesr:create\'
		     * @summary Create Non-Employee Source
		     * @param {NonEmployeeLifecycleManagementBetaApiCreateNonEmployeeSourceRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof NonEmployeeLifecycleManagementBetaApi
		     */
		    NonEmployeeLifecycleManagementBetaApi.prototype.createNonEmployeeSource = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.NonEmployeeLifecycleManagementBetaApiFp)(this.configuration).createNonEmployeeSource(requestParameters.nonEmployeeSourceRequestBodyBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API creates a new schema attribute for Non-Employee Source. The schema technical name must be unique in the source. Attempts to create a schema attribute with an existing name will result in a \"400.1.409 Reference conflict\" response. At most, 10 custom attributes can be created per schema. Attempts to create more than 10 will result in a \"400.1.4 Limit violation\" response.
		     * @summary Create Non-Employee Source Schema Attribute
		     * @param {NonEmployeeLifecycleManagementBetaApiCreateNonEmployeeSourceSchemaAttributesRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof NonEmployeeLifecycleManagementBetaApi
		     */
		    NonEmployeeLifecycleManagementBetaApi.prototype.createNonEmployeeSourceSchemaAttributes = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.NonEmployeeLifecycleManagementBetaApiFp)(this.configuration).createNonEmployeeSourceSchemaAttributes(requestParameters.sourceId, requestParameters.nonEmployeeSchemaAttributeBodyBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This request will delete a non-employee record.
		     * @summary Delete Non-Employee Record
		     * @param {NonEmployeeLifecycleManagementBetaApiDeleteNonEmployeeRecordRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof NonEmployeeLifecycleManagementBetaApi
		     */
		    NonEmployeeLifecycleManagementBetaApi.prototype.deleteNonEmployeeRecord = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.NonEmployeeLifecycleManagementBetaApiFp)(this.configuration).deleteNonEmployeeRecord(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This request will delete multiple non-employee records based on the non-employee ids provided. Request will require the following scope: \'idn:nesr:delete\'
		     * @summary Delete Multiple Non-Employee Records
		     * @param {NonEmployeeLifecycleManagementBetaApiDeleteNonEmployeeRecordInBulkRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof NonEmployeeLifecycleManagementBetaApi
		     */
		    NonEmployeeLifecycleManagementBetaApi.prototype.deleteNonEmployeeRecordInBulk = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.NonEmployeeLifecycleManagementBetaApiFp)(this.configuration).deleteNonEmployeeRecordInBulk(requestParameters.deleteNonEmployeeRecordInBulkRequestBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This request will delete a non-employee request.
		     * @summary Delete Non-Employee Request
		     * @param {NonEmployeeLifecycleManagementBetaApiDeleteNonEmployeeRequestRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof NonEmployeeLifecycleManagementBetaApi
		     */
		    NonEmployeeLifecycleManagementBetaApi.prototype.deleteNonEmployeeRequest = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.NonEmployeeLifecycleManagementBetaApiFp)(this.configuration).deleteNonEmployeeRequest(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This end-point deletes a specific schema attribute for a non-employee source.
		     * @summary Delete Non-Employee Source\'s Schema Attribute
		     * @param {NonEmployeeLifecycleManagementBetaApiDeleteNonEmployeeSchemaAttributeRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof NonEmployeeLifecycleManagementBetaApi
		     */
		    NonEmployeeLifecycleManagementBetaApi.prototype.deleteNonEmployeeSchemaAttribute = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.NonEmployeeLifecycleManagementBetaApiFp)(this.configuration).deleteNonEmployeeSchemaAttribute(requestParameters.attributeId, requestParameters.sourceId, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This request will delete a non-employee source.
		     * @summary Delete Non-Employee Source
		     * @param {NonEmployeeLifecycleManagementBetaApiDeleteNonEmployeeSourceRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof NonEmployeeLifecycleManagementBetaApi
		     */
		    NonEmployeeLifecycleManagementBetaApi.prototype.deleteNonEmployeeSource = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.NonEmployeeLifecycleManagementBetaApiFp)(this.configuration).deleteNonEmployeeSource(requestParameters.sourceId, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This end-point deletes all custom schema attributes for a non-employee source.
		     * @summary Delete all custom schema attributes
		     * @param {NonEmployeeLifecycleManagementBetaApiDeleteNonEmployeeSourceSchemaAttributesRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof NonEmployeeLifecycleManagementBetaApi
		     */
		    NonEmployeeLifecycleManagementBetaApi.prototype.deleteNonEmployeeSourceSchemaAttributes = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.NonEmployeeLifecycleManagementBetaApiFp)(this.configuration).deleteNonEmployeeSourceSchemaAttributes(requestParameters.sourceId, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This requests a CSV download for all non-employees from a provided source.
		     * @summary Exports Non-Employee Records to CSV
		     * @param {NonEmployeeLifecycleManagementBetaApiExportNonEmployeeRecordsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof NonEmployeeLifecycleManagementBetaApi
		     */
		    NonEmployeeLifecycleManagementBetaApi.prototype.exportNonEmployeeRecords = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.NonEmployeeLifecycleManagementBetaApiFp)(this.configuration).exportNonEmployeeRecords(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This requests a download for the Source Schema Template for a provided source. Request will require the following security scope: idn:nesr:read\'
		     * @summary Exports Source Schema Template
		     * @param {NonEmployeeLifecycleManagementBetaApiExportNonEmployeeSourceSchemaTemplateRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof NonEmployeeLifecycleManagementBetaApi
		     */
		    NonEmployeeLifecycleManagementBetaApi.prototype.exportNonEmployeeSourceSchemaTemplate = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.NonEmployeeLifecycleManagementBetaApiFp)(this.configuration).exportNonEmployeeSourceSchemaTemplate(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Approves a non-employee approval request and notifies the next approver.
		     * @summary Get a non-employee approval item detail
		     * @param {NonEmployeeLifecycleManagementBetaApiGetNonEmployeeApprovalRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof NonEmployeeLifecycleManagementBetaApi
		     */
		    NonEmployeeLifecycleManagementBetaApi.prototype.getNonEmployeeApproval = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.NonEmployeeLifecycleManagementBetaApiFp)(this.configuration).getNonEmployeeApproval(requestParameters.id, requestParameters.includeDetail, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This request will retrieve a summary of non-employee approval requests. There are two contextual uses for the `requested-for` path parameter: 1. The current user is the Org Admin, in which case he or she may request a summary of all non-employee approval requests assigned to a particular approver by passing in that approver\'s id. 2. The current user is an approver, in which case \"me\" should be provided as the `requested-for` value. This will provide the approver with a summary of the approval items assigned to him or her.
		     * @summary Get Summary of Non-Employee Approval Requests
		     * @param {NonEmployeeLifecycleManagementBetaApiGetNonEmployeeApprovalSummaryRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof NonEmployeeLifecycleManagementBetaApi
		     */
		    NonEmployeeLifecycleManagementBetaApi.prototype.getNonEmployeeApprovalSummary = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.NonEmployeeLifecycleManagementBetaApiFp)(this.configuration).getNonEmployeeApprovalSummary(requestParameters.requestedFor, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * The nonEmployeeBulkUploadStatus API returns the status of the newest bulk upload job for the specified source.
		     * @summary Bulk upload status on source
		     * @param {NonEmployeeLifecycleManagementBetaApiGetNonEmployeeBulkUploadStatusRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof NonEmployeeLifecycleManagementBetaApi
		     */
		    NonEmployeeLifecycleManagementBetaApi.prototype.getNonEmployeeBulkUploadStatus = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.NonEmployeeLifecycleManagementBetaApiFp)(this.configuration).getNonEmployeeBulkUploadStatus(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This gets a non-employee record.
		     * @summary Get a Non-Employee Record
		     * @param {NonEmployeeLifecycleManagementBetaApiGetNonEmployeeRecordRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof NonEmployeeLifecycleManagementBetaApi
		     */
		    NonEmployeeLifecycleManagementBetaApi.prototype.getNonEmployeeRecord = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.NonEmployeeLifecycleManagementBetaApiFp)(this.configuration).getNonEmployeeRecord(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This gets a non-employee request.
		     * @summary Get a Non-Employee Request
		     * @param {NonEmployeeLifecycleManagementBetaApiGetNonEmployeeRequestRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof NonEmployeeLifecycleManagementBetaApi
		     */
		    NonEmployeeLifecycleManagementBetaApi.prototype.getNonEmployeeRequest = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.NonEmployeeLifecycleManagementBetaApiFp)(this.configuration).getNonEmployeeRequest(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This request will retrieve a summary of non-employee requests. There are two contextual uses for the `requested-for` path parameter: 1. The current user is the Org Admin, in which case he or she may request a summary of all non-employee approval requests assigned to a particular account manager by passing in that manager\'s id. 2. The current user is an account manager, in which case \"me\" should be provided as the `requested-for` value. This will provide the user with a summary of the non-employee requests in the source(s) he or she manages.
		     * @summary Get Summary of Non-Employee Requests
		     * @param {NonEmployeeLifecycleManagementBetaApiGetNonEmployeeRequestSummaryRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof NonEmployeeLifecycleManagementBetaApi
		     */
		    NonEmployeeLifecycleManagementBetaApi.prototype.getNonEmployeeRequestSummary = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.NonEmployeeLifecycleManagementBetaApiFp)(this.configuration).getNonEmployeeRequestSummary(requestParameters.requestedFor, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API gets a schema attribute by Id for the specified Non-Employee SourceId.
		     * @summary Get Schema Attribute Non-Employee Source
		     * @param {NonEmployeeLifecycleManagementBetaApiGetNonEmployeeSchemaAttributeRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof NonEmployeeLifecycleManagementBetaApi
		     */
		    NonEmployeeLifecycleManagementBetaApi.prototype.getNonEmployeeSchemaAttribute = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.NonEmployeeLifecycleManagementBetaApiFp)(this.configuration).getNonEmployeeSchemaAttribute(requestParameters.attributeId, requestParameters.sourceId, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This gets a non-employee source.
		     * @summary Get a Non-Employee Source
		     * @param {NonEmployeeLifecycleManagementBetaApiGetNonEmployeeSourceRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof NonEmployeeLifecycleManagementBetaApi
		     */
		    NonEmployeeLifecycleManagementBetaApi.prototype.getNonEmployeeSource = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.NonEmployeeLifecycleManagementBetaApiFp)(this.configuration).getNonEmployeeSource(requestParameters.sourceId, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API gets the list of schema attributes for the specified Non-Employee SourceId. There are 8 mandatory attributes added to each new Non-Employee Source automatically. Additionaly, user can add up to 10 custom attributes. This interface returns all the mandatory attributes followed by any custom attributes. At most, a total of 18 attributes will be returned.
		     * @summary List Schema Attributes Non-Employee Source
		     * @param {NonEmployeeLifecycleManagementBetaApiGetNonEmployeeSourceSchemaAttributesRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof NonEmployeeLifecycleManagementBetaApi
		     */
		    NonEmployeeLifecycleManagementBetaApi.prototype.getNonEmployeeSourceSchemaAttributes = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.NonEmployeeLifecycleManagementBetaApiFp)(this.configuration).getNonEmployeeSourceSchemaAttributes(requestParameters.sourceId, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This post will import, or update, Non-Employee records found in the CSV. Request will need the following security scope: \'idn:nesr:create\'
		     * @summary Imports, or Updates, Non-Employee Records
		     * @param {NonEmployeeLifecycleManagementBetaApiImportNonEmployeeRecordsInBulkRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof NonEmployeeLifecycleManagementBetaApi
		     */
		    NonEmployeeLifecycleManagementBetaApi.prototype.importNonEmployeeRecordsInBulk = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.NonEmployeeLifecycleManagementBetaApiFp)(this.configuration).importNonEmployeeRecordsInBulk(requestParameters.id, requestParameters.data, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This gets a list of non-employee approval requests.
		     * @summary Get List of Non-Employee Approval Requests
		     * @param {NonEmployeeLifecycleManagementBetaApiListNonEmployeeApprovalRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof NonEmployeeLifecycleManagementBetaApi
		     */
		    NonEmployeeLifecycleManagementBetaApi.prototype.listNonEmployeeApproval = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.NonEmployeeLifecycleManagementBetaApiFp)(this.configuration).listNonEmployeeApproval(requestParameters.requestedFor, requestParameters.limit, requestParameters.offset, requestParameters.count, requestParameters.filters, requestParameters.sorters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This gets a list of non-employee records.
		     * @summary List Non-Employee Records
		     * @param {NonEmployeeLifecycleManagementBetaApiListNonEmployeeRecordsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof NonEmployeeLifecycleManagementBetaApi
		     */
		    NonEmployeeLifecycleManagementBetaApi.prototype.listNonEmployeeRecords = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.NonEmployeeLifecycleManagementBetaApiFp)(this.configuration).listNonEmployeeRecords(requestParameters.limit, requestParameters.offset, requestParameters.count, requestParameters.sorters, requestParameters.filters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This gets a list of non-employee requests.
		     * @summary List Non-Employee Requests
		     * @param {NonEmployeeLifecycleManagementBetaApiListNonEmployeeRequestsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof NonEmployeeLifecycleManagementBetaApi
		     */
		    NonEmployeeLifecycleManagementBetaApi.prototype.listNonEmployeeRequests = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.NonEmployeeLifecycleManagementBetaApiFp)(this.configuration).listNonEmployeeRequests(requestParameters.requestedFor, requestParameters.limit, requestParameters.offset, requestParameters.count, requestParameters.sorters, requestParameters.filters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This gets a list of non-employee sources.
		     * @summary List Non-Employee Sources
		     * @param {NonEmployeeLifecycleManagementBetaApiListNonEmployeeSourcesRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof NonEmployeeLifecycleManagementBetaApi
		     */
		    NonEmployeeLifecycleManagementBetaApi.prototype.listNonEmployeeSources = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.NonEmployeeLifecycleManagementBetaApiFp)(this.configuration).listNonEmployeeSources(requestParameters.requestedFor, requestParameters.nonEmployeeCount, requestParameters.limit, requestParameters.offset, requestParameters.count, requestParameters.sorters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This request will patch a non-employee record.
		     * @summary Patch Non-Employee Record
		     * @param {NonEmployeeLifecycleManagementBetaApiPatchNonEmployeeRecordRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof NonEmployeeLifecycleManagementBetaApi
		     */
		    NonEmployeeLifecycleManagementBetaApi.prototype.patchNonEmployeeRecord = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.NonEmployeeLifecycleManagementBetaApiFp)(this.configuration).patchNonEmployeeRecord(requestParameters.id, requestParameters.jsonPatchOperationBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This end-point patches a specific schema attribute for a non-employee SourceId.
		     * @summary Patch Non-Employee Source\'s Schema Attribute
		     * @param {NonEmployeeLifecycleManagementBetaApiPatchNonEmployeeSchemaAttributeRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof NonEmployeeLifecycleManagementBetaApi
		     */
		    NonEmployeeLifecycleManagementBetaApi.prototype.patchNonEmployeeSchemaAttribute = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.NonEmployeeLifecycleManagementBetaApiFp)(this.configuration).patchNonEmployeeSchemaAttribute(requestParameters.attributeId, requestParameters.sourceId, requestParameters.jsonPatchOperationBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * patch a non-employee source. (Partial Update)  Patchable field: **name, description, approvers, accountManagers**
		     * @summary Patch a Non-Employee Source
		     * @param {NonEmployeeLifecycleManagementBetaApiPatchNonEmployeeSourceRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof NonEmployeeLifecycleManagementBetaApi
		     */
		    NonEmployeeLifecycleManagementBetaApi.prototype.patchNonEmployeeSource = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.NonEmployeeLifecycleManagementBetaApiFp)(this.configuration).patchNonEmployeeSource(requestParameters.sourceId, requestParameters.jsonPatchOperationBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This endpoint will reject an approval item request and notify user.
		     * @summary Reject a Non-Employee Request
		     * @param {NonEmployeeLifecycleManagementBetaApiRejectNonEmployeeRequestRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof NonEmployeeLifecycleManagementBetaApi
		     */
		    NonEmployeeLifecycleManagementBetaApi.prototype.rejectNonEmployeeRequest = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.NonEmployeeLifecycleManagementBetaApiFp)(this.configuration).rejectNonEmployeeRequest(requestParameters.id, requestParameters.nonEmployeeRejectApprovalDecisionBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This request will update a non-employee record.
		     * @summary Update Non-Employee Record
		     * @param {NonEmployeeLifecycleManagementBetaApiUpdateNonEmployeeRecordRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof NonEmployeeLifecycleManagementBetaApi
		     */
		    NonEmployeeLifecycleManagementBetaApi.prototype.updateNonEmployeeRecord = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.NonEmployeeLifecycleManagementBetaApiFp)(this.configuration).updateNonEmployeeRecord(requestParameters.id, requestParameters.nonEmployeeRequestBodyBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return NonEmployeeLifecycleManagementBetaApi;
		}(base_1.BaseAPI));
		exports.NonEmployeeLifecycleManagementBetaApi = NonEmployeeLifecycleManagementBetaApi;
		/**
		 * NotificationsBetaApi - axios parameter creator
		 * @export
		 */
		var NotificationsBetaApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * Create a domain to be verified via DKIM (DomainKeys Identified Mail)
		         * @summary Verify domain address via DKIM
		         * @param {DomainAddressBeta} domainAddressBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createDomainDkim: function (domainAddressBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'domainAddressBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('createDomainDkim', 'domainAddressBeta', domainAddressBeta);
		                            localVarPath = "/verified-domains";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(domainAddressBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This creates a template for your site.   You can also use this endpoint to update a template.  First, copy the response body from the [get notification template endpoint](https://developer.sailpoint.com/idn/api/beta/get-notification-template) for a template you wish to update and paste it into the request body for this endpoint.   Modify the fields you want to change and submit the POST request when ready.
		         * @summary Create Notification Template
		         * @param {TemplateDtoBeta} templateDtoBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createNotificationTemplate: function (templateDtoBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'templateDtoBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('createNotificationTemplate', 'templateDtoBeta', templateDtoBeta);
		                            localVarPath = "/notification-templates";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(templateDtoBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Create a new sender email address and initiate verification process.
		         * @summary Create Verified From Address
		         * @param {EmailStatusDtoBeta} emailStatusDtoBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createVerifiedFromAddress: function (emailStatusDtoBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'emailStatusDtoBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('createVerifiedFromAddress', 'emailStatusDtoBeta', emailStatusDtoBeta);
		                            localVarPath = "/verified-from-addresses";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(emailStatusDtoBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This lets you bulk delete templates that you previously created for your site. Since this is a beta feature, you can only delete a subset of your notifications, i.e. ones that show up in the list call.
		         * @summary Bulk Delete Notification Templates
		         * @param {Array<TemplateBulkDeleteDtoBeta>} templateBulkDeleteDtoBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteNotificationTemplatesInBulk: function (templateBulkDeleteDtoBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'templateBulkDeleteDtoBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('deleteNotificationTemplatesInBulk', 'templateBulkDeleteDtoBeta', templateBulkDeleteDtoBeta);
		                            localVarPath = "/notification-templates/bulk-delete";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(templateBulkDeleteDtoBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Delete a verified sender email address
		         * @summary Delete Verified From Address
		         * @param {string} id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteVerifiedFromAddress: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('deleteVerifiedFromAddress', 'id', id);
		                            localVarPath = "/verified-from-addresses/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'DELETE' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Retrieve DKIM (DomainKeys Identified Mail) attributes for all your tenants\' AWS SES identities. Limits retrieval to 100 identities per call.
		         * @summary Get DKIM Attributes
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getDkimAttributes: function (axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/verified-domains";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Retrieve MAIL FROM attributes for a given AWS SES identity.
		         * @summary Get MAIL FROM Attributes
		         * @param {string} id Returns the MX and TXT record to be put in your DNS, as well as the MAIL FROM domain status
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getMailFromAttributes: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getMailFromAttributes', 'id', id);
		                            localVarPath = "/mail-from-attributes/{identity}";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (id !== undefined) {
		                                localVarQueryParameter['id'] = id;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Returns the notification preferences for tenant.  Note that if the key doesn\'t exist, then a 404 will be returned. Request will require the following legacy roles:  ORG_ADMIN and API
		         * @summary Get Notification Preferences for tenant.
		         * @param {string} key The notification key.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getNotificationPreference: function (key, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'key' is not null or undefined
		                            (0, common_1.assertParamExists)('getNotificationPreference', 'key', key);
		                            localVarPath = "/notification-preferences/{key}"
		                                .replace("{".concat("key", "}"), encodeURIComponent(String(key)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets a template that you have modified for your site by Id.
		         * @summary Get Notification Template By Id
		         * @param {string} id Id of the Notification Template
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getNotificationTemplate: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getNotificationTemplate', 'id', id);
		                            localVarPath = "/notification-templates/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * The notification service (Hermes) maintains metadata to construct the notification templates or supply any information during the event propagation.  The data-store where this information is retrieved is  called \"Global Context\" (a.k.a. notification template context). It defines a set of attributes  that will be available per tenant (organization).  Regarding authorization, the access token contains the tenant and will grant access to the one requested. Requires the following security scope:  idn:notification-templates:read
		         * @summary Get Notification Template Context
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getNotificationsTemplateContext: function (axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/notification-template-context";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Retrieve a list of sender email addresses and their verification statuses
		         * @summary List From Addresses
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **email**: *eq, ge, le, sw*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **email**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listFromAddresses: function (limit, offset, count, filters, sorters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/verified-from-addresses";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This lists the default templates used for notifications, such as emails from IdentityNow. Since this is a beta feature, it doesn\'t include all the templates.
		         * @summary List Notification Template Defaults
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **key**: *eq, in, sw*  **medium**: *eq, sw*  **locale**: *eq, sw*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listNotificationTemplateDefaults: function (limit, offset, filters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/notification-template-defaults";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This lists the templates that you have modified for your site. Since this is a beta feature, it doesn\'t include all your modified templates.
		         * @summary List Notification Templates
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **key**: *eq, in, sw*  **medium**: *eq, sw*  **locale**: *eq, sw*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listNotificationTemplates: function (limit, offset, filters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/notification-templates";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Change the MAIL FROM domain of an AWS SES email identity and provide the MX and TXT records to be placed in the caller\'s DNS
		         * @summary Change MAIL FROM domain
		         * @param {MailFromAttributesDtoBeta} mailFromAttributesDtoBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putMailFromAttributes: function (mailFromAttributesDtoBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'mailFromAttributesDtoBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('putMailFromAttributes', 'mailFromAttributesDtoBeta', mailFromAttributesDtoBeta);
		                            localVarPath = "/mail-from-attributes";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PUT' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(mailFromAttributesDtoBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * In the notification world, a notification flows through these salient stages -   1. Interest matching,   2. Preferences   3. Template Rendering.   The default notification preferences make up a part of the second stage, along with user preferences (which is a future goal). The expectation is for  admins to be able to set default preferences for their org, like opting in to or out of certain notifications, and configuring future preferences as  we tack on more features. The key in the Dto is not necessary but if it is provided and doesn\'t match the key in the URI, then a 400 will be thrown.  Request will require the following legacy roles:  ORG_ADMIN and API
		         * @summary Overwrite the preferences for the given notification key.
		         * @param {string} key The notification key.
		         * @param {PreferencesDtoBeta} preferencesDtoBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putNotificationPreference: function (key, preferencesDtoBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'key' is not null or undefined
		                            (0, common_1.assertParamExists)('putNotificationPreference', 'key', key);
		                            // verify required parameter 'preferencesDtoBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('putNotificationPreference', 'preferencesDtoBeta', preferencesDtoBeta);
		                            localVarPath = "/notification-preferences/{key}"
		                                .replace("{".concat("key", "}"), encodeURIComponent(String(key)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PUT' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(preferencesDtoBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Send a Test Notification
		         * @summary Send Test Notification
		         * @param {SendTestNotificationRequestDtoBeta} sendTestNotificationRequestDtoBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        sendTestNotification: function (sendTestNotificationRequestDtoBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'sendTestNotificationRequestDtoBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('sendTestNotification', 'sendTestNotificationRequestDtoBeta', sendTestNotificationRequestDtoBeta);
		                            localVarPath = "/send-test-notification";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(sendTestNotificationRequestDtoBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.NotificationsBetaApiAxiosParamCreator = NotificationsBetaApiAxiosParamCreator;
		/**
		 * NotificationsBetaApi - functional programming interface
		 * @export
		 */
		var NotificationsBetaApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.NotificationsBetaApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * Create a domain to be verified via DKIM (DomainKeys Identified Mail)
		         * @summary Verify domain address via DKIM
		         * @param {DomainAddressBeta} domainAddressBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createDomainDkim: function (domainAddressBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.createDomainDkim(domainAddressBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This creates a template for your site.   You can also use this endpoint to update a template.  First, copy the response body from the [get notification template endpoint](https://developer.sailpoint.com/idn/api/beta/get-notification-template) for a template you wish to update and paste it into the request body for this endpoint.   Modify the fields you want to change and submit the POST request when ready.
		         * @summary Create Notification Template
		         * @param {TemplateDtoBeta} templateDtoBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createNotificationTemplate: function (templateDtoBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.createNotificationTemplate(templateDtoBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Create a new sender email address and initiate verification process.
		         * @summary Create Verified From Address
		         * @param {EmailStatusDtoBeta} emailStatusDtoBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createVerifiedFromAddress: function (emailStatusDtoBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.createVerifiedFromAddress(emailStatusDtoBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This lets you bulk delete templates that you previously created for your site. Since this is a beta feature, you can only delete a subset of your notifications, i.e. ones that show up in the list call.
		         * @summary Bulk Delete Notification Templates
		         * @param {Array<TemplateBulkDeleteDtoBeta>} templateBulkDeleteDtoBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteNotificationTemplatesInBulk: function (templateBulkDeleteDtoBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.deleteNotificationTemplatesInBulk(templateBulkDeleteDtoBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Delete a verified sender email address
		         * @summary Delete Verified From Address
		         * @param {string} id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteVerifiedFromAddress: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.deleteVerifiedFromAddress(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Retrieve DKIM (DomainKeys Identified Mail) attributes for all your tenants\' AWS SES identities. Limits retrieval to 100 identities per call.
		         * @summary Get DKIM Attributes
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getDkimAttributes: function (axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getDkimAttributes(axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Retrieve MAIL FROM attributes for a given AWS SES identity.
		         * @summary Get MAIL FROM Attributes
		         * @param {string} id Returns the MX and TXT record to be put in your DNS, as well as the MAIL FROM domain status
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getMailFromAttributes: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getMailFromAttributes(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Returns the notification preferences for tenant.  Note that if the key doesn\'t exist, then a 404 will be returned. Request will require the following legacy roles:  ORG_ADMIN and API
		         * @summary Get Notification Preferences for tenant.
		         * @param {string} key The notification key.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getNotificationPreference: function (key, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getNotificationPreference(key, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets a template that you have modified for your site by Id.
		         * @summary Get Notification Template By Id
		         * @param {string} id Id of the Notification Template
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getNotificationTemplate: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getNotificationTemplate(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * The notification service (Hermes) maintains metadata to construct the notification templates or supply any information during the event propagation.  The data-store where this information is retrieved is  called \"Global Context\" (a.k.a. notification template context). It defines a set of attributes  that will be available per tenant (organization).  Regarding authorization, the access token contains the tenant and will grant access to the one requested. Requires the following security scope:  idn:notification-templates:read
		         * @summary Get Notification Template Context
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getNotificationsTemplateContext: function (axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getNotificationsTemplateContext(axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Retrieve a list of sender email addresses and their verification statuses
		         * @summary List From Addresses
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **email**: *eq, ge, le, sw*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **email**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listFromAddresses: function (limit, offset, count, filters, sorters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listFromAddresses(limit, offset, count, filters, sorters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This lists the default templates used for notifications, such as emails from IdentityNow. Since this is a beta feature, it doesn\'t include all the templates.
		         * @summary List Notification Template Defaults
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **key**: *eq, in, sw*  **medium**: *eq, sw*  **locale**: *eq, sw*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listNotificationTemplateDefaults: function (limit, offset, filters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listNotificationTemplateDefaults(limit, offset, filters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This lists the templates that you have modified for your site. Since this is a beta feature, it doesn\'t include all your modified templates.
		         * @summary List Notification Templates
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **key**: *eq, in, sw*  **medium**: *eq, sw*  **locale**: *eq, sw*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listNotificationTemplates: function (limit, offset, filters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listNotificationTemplates(limit, offset, filters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Change the MAIL FROM domain of an AWS SES email identity and provide the MX and TXT records to be placed in the caller\'s DNS
		         * @summary Change MAIL FROM domain
		         * @param {MailFromAttributesDtoBeta} mailFromAttributesDtoBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putMailFromAttributes: function (mailFromAttributesDtoBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.putMailFromAttributes(mailFromAttributesDtoBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * In the notification world, a notification flows through these salient stages -   1. Interest matching,   2. Preferences   3. Template Rendering.   The default notification preferences make up a part of the second stage, along with user preferences (which is a future goal). The expectation is for  admins to be able to set default preferences for their org, like opting in to or out of certain notifications, and configuring future preferences as  we tack on more features. The key in the Dto is not necessary but if it is provided and doesn\'t match the key in the URI, then a 400 will be thrown.  Request will require the following legacy roles:  ORG_ADMIN and API
		         * @summary Overwrite the preferences for the given notification key.
		         * @param {string} key The notification key.
		         * @param {PreferencesDtoBeta} preferencesDtoBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putNotificationPreference: function (key, preferencesDtoBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.putNotificationPreference(key, preferencesDtoBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Send a Test Notification
		         * @summary Send Test Notification
		         * @param {SendTestNotificationRequestDtoBeta} sendTestNotificationRequestDtoBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        sendTestNotification: function (sendTestNotificationRequestDtoBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.sendTestNotification(sendTestNotificationRequestDtoBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.NotificationsBetaApiFp = NotificationsBetaApiFp;
		/**
		 * NotificationsBetaApi - factory interface
		 * @export
		 */
		var NotificationsBetaApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.NotificationsBetaApiFp)(configuration);
		    return {
		        /**
		         * Create a domain to be verified via DKIM (DomainKeys Identified Mail)
		         * @summary Verify domain address via DKIM
		         * @param {DomainAddressBeta} domainAddressBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createDomainDkim: function (domainAddressBeta, axiosOptions) {
		            return localVarFp.createDomainDkim(domainAddressBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This creates a template for your site.   You can also use this endpoint to update a template.  First, copy the response body from the [get notification template endpoint](https://developer.sailpoint.com/idn/api/beta/get-notification-template) for a template you wish to update and paste it into the request body for this endpoint.   Modify the fields you want to change and submit the POST request when ready.
		         * @summary Create Notification Template
		         * @param {TemplateDtoBeta} templateDtoBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createNotificationTemplate: function (templateDtoBeta, axiosOptions) {
		            return localVarFp.createNotificationTemplate(templateDtoBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Create a new sender email address and initiate verification process.
		         * @summary Create Verified From Address
		         * @param {EmailStatusDtoBeta} emailStatusDtoBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createVerifiedFromAddress: function (emailStatusDtoBeta, axiosOptions) {
		            return localVarFp.createVerifiedFromAddress(emailStatusDtoBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This lets you bulk delete templates that you previously created for your site. Since this is a beta feature, you can only delete a subset of your notifications, i.e. ones that show up in the list call.
		         * @summary Bulk Delete Notification Templates
		         * @param {Array<TemplateBulkDeleteDtoBeta>} templateBulkDeleteDtoBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteNotificationTemplatesInBulk: function (templateBulkDeleteDtoBeta, axiosOptions) {
		            return localVarFp.deleteNotificationTemplatesInBulk(templateBulkDeleteDtoBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Delete a verified sender email address
		         * @summary Delete Verified From Address
		         * @param {string} id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteVerifiedFromAddress: function (id, axiosOptions) {
		            return localVarFp.deleteVerifiedFromAddress(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Retrieve DKIM (DomainKeys Identified Mail) attributes for all your tenants\' AWS SES identities. Limits retrieval to 100 identities per call.
		         * @summary Get DKIM Attributes
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getDkimAttributes: function (axiosOptions) {
		            return localVarFp.getDkimAttributes(axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Retrieve MAIL FROM attributes for a given AWS SES identity.
		         * @summary Get MAIL FROM Attributes
		         * @param {string} id Returns the MX and TXT record to be put in your DNS, as well as the MAIL FROM domain status
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getMailFromAttributes: function (id, axiosOptions) {
		            return localVarFp.getMailFromAttributes(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Returns the notification preferences for tenant.  Note that if the key doesn\'t exist, then a 404 will be returned. Request will require the following legacy roles:  ORG_ADMIN and API
		         * @summary Get Notification Preferences for tenant.
		         * @param {string} key The notification key.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getNotificationPreference: function (key, axiosOptions) {
		            return localVarFp.getNotificationPreference(key, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This gets a template that you have modified for your site by Id.
		         * @summary Get Notification Template By Id
		         * @param {string} id Id of the Notification Template
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getNotificationTemplate: function (id, axiosOptions) {
		            return localVarFp.getNotificationTemplate(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * The notification service (Hermes) maintains metadata to construct the notification templates or supply any information during the event propagation.  The data-store where this information is retrieved is  called \"Global Context\" (a.k.a. notification template context). It defines a set of attributes  that will be available per tenant (organization).  Regarding authorization, the access token contains the tenant and will grant access to the one requested. Requires the following security scope:  idn:notification-templates:read
		         * @summary Get Notification Template Context
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getNotificationsTemplateContext: function (axiosOptions) {
		            return localVarFp.getNotificationsTemplateContext(axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Retrieve a list of sender email addresses and their verification statuses
		         * @summary List From Addresses
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **email**: *eq, ge, le, sw*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **email**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listFromAddresses: function (limit, offset, count, filters, sorters, axiosOptions) {
		            return localVarFp.listFromAddresses(limit, offset, count, filters, sorters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This lists the default templates used for notifications, such as emails from IdentityNow. Since this is a beta feature, it doesn\'t include all the templates.
		         * @summary List Notification Template Defaults
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **key**: *eq, in, sw*  **medium**: *eq, sw*  **locale**: *eq, sw*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listNotificationTemplateDefaults: function (limit, offset, filters, axiosOptions) {
		            return localVarFp.listNotificationTemplateDefaults(limit, offset, filters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This lists the templates that you have modified for your site. Since this is a beta feature, it doesn\'t include all your modified templates.
		         * @summary List Notification Templates
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **key**: *eq, in, sw*  **medium**: *eq, sw*  **locale**: *eq, sw*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listNotificationTemplates: function (limit, offset, filters, axiosOptions) {
		            return localVarFp.listNotificationTemplates(limit, offset, filters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Change the MAIL FROM domain of an AWS SES email identity and provide the MX and TXT records to be placed in the caller\'s DNS
		         * @summary Change MAIL FROM domain
		         * @param {MailFromAttributesDtoBeta} mailFromAttributesDtoBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putMailFromAttributes: function (mailFromAttributesDtoBeta, axiosOptions) {
		            return localVarFp.putMailFromAttributes(mailFromAttributesDtoBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * In the notification world, a notification flows through these salient stages -   1. Interest matching,   2. Preferences   3. Template Rendering.   The default notification preferences make up a part of the second stage, along with user preferences (which is a future goal). The expectation is for  admins to be able to set default preferences for their org, like opting in to or out of certain notifications, and configuring future preferences as  we tack on more features. The key in the Dto is not necessary but if it is provided and doesn\'t match the key in the URI, then a 400 will be thrown.  Request will require the following legacy roles:  ORG_ADMIN and API
		         * @summary Overwrite the preferences for the given notification key.
		         * @param {string} key The notification key.
		         * @param {PreferencesDtoBeta} preferencesDtoBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putNotificationPreference: function (key, preferencesDtoBeta, axiosOptions) {
		            return localVarFp.putNotificationPreference(key, preferencesDtoBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Send a Test Notification
		         * @summary Send Test Notification
		         * @param {SendTestNotificationRequestDtoBeta} sendTestNotificationRequestDtoBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        sendTestNotification: function (sendTestNotificationRequestDtoBeta, axiosOptions) {
		            return localVarFp.sendTestNotification(sendTestNotificationRequestDtoBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.NotificationsBetaApiFactory = NotificationsBetaApiFactory;
		/**
		 * NotificationsBetaApi - object-oriented interface
		 * @export
		 * @class NotificationsBetaApi
		 * @extends {BaseAPI}
		 */
		var NotificationsBetaApi = /** @class */ (function (_super) {
		    __extends(NotificationsBetaApi, _super);
		    function NotificationsBetaApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * Create a domain to be verified via DKIM (DomainKeys Identified Mail)
		     * @summary Verify domain address via DKIM
		     * @param {NotificationsBetaApiCreateDomainDkimRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof NotificationsBetaApi
		     */
		    NotificationsBetaApi.prototype.createDomainDkim = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.NotificationsBetaApiFp)(this.configuration).createDomainDkim(requestParameters.domainAddressBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This creates a template for your site.   You can also use this endpoint to update a template.  First, copy the response body from the [get notification template endpoint](https://developer.sailpoint.com/idn/api/beta/get-notification-template) for a template you wish to update and paste it into the request body for this endpoint.   Modify the fields you want to change and submit the POST request when ready.
		     * @summary Create Notification Template
		     * @param {NotificationsBetaApiCreateNotificationTemplateRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof NotificationsBetaApi
		     */
		    NotificationsBetaApi.prototype.createNotificationTemplate = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.NotificationsBetaApiFp)(this.configuration).createNotificationTemplate(requestParameters.templateDtoBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Create a new sender email address and initiate verification process.
		     * @summary Create Verified From Address
		     * @param {NotificationsBetaApiCreateVerifiedFromAddressRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof NotificationsBetaApi
		     */
		    NotificationsBetaApi.prototype.createVerifiedFromAddress = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.NotificationsBetaApiFp)(this.configuration).createVerifiedFromAddress(requestParameters.emailStatusDtoBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This lets you bulk delete templates that you previously created for your site. Since this is a beta feature, you can only delete a subset of your notifications, i.e. ones that show up in the list call.
		     * @summary Bulk Delete Notification Templates
		     * @param {NotificationsBetaApiDeleteNotificationTemplatesInBulkRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof NotificationsBetaApi
		     */
		    NotificationsBetaApi.prototype.deleteNotificationTemplatesInBulk = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.NotificationsBetaApiFp)(this.configuration).deleteNotificationTemplatesInBulk(requestParameters.templateBulkDeleteDtoBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Delete a verified sender email address
		     * @summary Delete Verified From Address
		     * @param {NotificationsBetaApiDeleteVerifiedFromAddressRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof NotificationsBetaApi
		     */
		    NotificationsBetaApi.prototype.deleteVerifiedFromAddress = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.NotificationsBetaApiFp)(this.configuration).deleteVerifiedFromAddress(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Retrieve DKIM (DomainKeys Identified Mail) attributes for all your tenants\' AWS SES identities. Limits retrieval to 100 identities per call.
		     * @summary Get DKIM Attributes
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof NotificationsBetaApi
		     */
		    NotificationsBetaApi.prototype.getDkimAttributes = function (axiosOptions) {
		        var _this = this;
		        return (0, exports.NotificationsBetaApiFp)(this.configuration).getDkimAttributes(axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Retrieve MAIL FROM attributes for a given AWS SES identity.
		     * @summary Get MAIL FROM Attributes
		     * @param {NotificationsBetaApiGetMailFromAttributesRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof NotificationsBetaApi
		     */
		    NotificationsBetaApi.prototype.getMailFromAttributes = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.NotificationsBetaApiFp)(this.configuration).getMailFromAttributes(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Returns the notification preferences for tenant.  Note that if the key doesn\'t exist, then a 404 will be returned. Request will require the following legacy roles:  ORG_ADMIN and API
		     * @summary Get Notification Preferences for tenant.
		     * @param {NotificationsBetaApiGetNotificationPreferenceRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof NotificationsBetaApi
		     */
		    NotificationsBetaApi.prototype.getNotificationPreference = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.NotificationsBetaApiFp)(this.configuration).getNotificationPreference(requestParameters.key, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This gets a template that you have modified for your site by Id.
		     * @summary Get Notification Template By Id
		     * @param {NotificationsBetaApiGetNotificationTemplateRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof NotificationsBetaApi
		     */
		    NotificationsBetaApi.prototype.getNotificationTemplate = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.NotificationsBetaApiFp)(this.configuration).getNotificationTemplate(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * The notification service (Hermes) maintains metadata to construct the notification templates or supply any information during the event propagation.  The data-store where this information is retrieved is  called \"Global Context\" (a.k.a. notification template context). It defines a set of attributes  that will be available per tenant (organization).  Regarding authorization, the access token contains the tenant and will grant access to the one requested. Requires the following security scope:  idn:notification-templates:read
		     * @summary Get Notification Template Context
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof NotificationsBetaApi
		     */
		    NotificationsBetaApi.prototype.getNotificationsTemplateContext = function (axiosOptions) {
		        var _this = this;
		        return (0, exports.NotificationsBetaApiFp)(this.configuration).getNotificationsTemplateContext(axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Retrieve a list of sender email addresses and their verification statuses
		     * @summary List From Addresses
		     * @param {NotificationsBetaApiListFromAddressesRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof NotificationsBetaApi
		     */
		    NotificationsBetaApi.prototype.listFromAddresses = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.NotificationsBetaApiFp)(this.configuration).listFromAddresses(requestParameters.limit, requestParameters.offset, requestParameters.count, requestParameters.filters, requestParameters.sorters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This lists the default templates used for notifications, such as emails from IdentityNow. Since this is a beta feature, it doesn\'t include all the templates.
		     * @summary List Notification Template Defaults
		     * @param {NotificationsBetaApiListNotificationTemplateDefaultsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof NotificationsBetaApi
		     */
		    NotificationsBetaApi.prototype.listNotificationTemplateDefaults = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.NotificationsBetaApiFp)(this.configuration).listNotificationTemplateDefaults(requestParameters.limit, requestParameters.offset, requestParameters.filters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This lists the templates that you have modified for your site. Since this is a beta feature, it doesn\'t include all your modified templates.
		     * @summary List Notification Templates
		     * @param {NotificationsBetaApiListNotificationTemplatesRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof NotificationsBetaApi
		     */
		    NotificationsBetaApi.prototype.listNotificationTemplates = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.NotificationsBetaApiFp)(this.configuration).listNotificationTemplates(requestParameters.limit, requestParameters.offset, requestParameters.filters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Change the MAIL FROM domain of an AWS SES email identity and provide the MX and TXT records to be placed in the caller\'s DNS
		     * @summary Change MAIL FROM domain
		     * @param {NotificationsBetaApiPutMailFromAttributesRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof NotificationsBetaApi
		     */
		    NotificationsBetaApi.prototype.putMailFromAttributes = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.NotificationsBetaApiFp)(this.configuration).putMailFromAttributes(requestParameters.mailFromAttributesDtoBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * In the notification world, a notification flows through these salient stages -   1. Interest matching,   2. Preferences   3. Template Rendering.   The default notification preferences make up a part of the second stage, along with user preferences (which is a future goal). The expectation is for  admins to be able to set default preferences for their org, like opting in to or out of certain notifications, and configuring future preferences as  we tack on more features. The key in the Dto is not necessary but if it is provided and doesn\'t match the key in the URI, then a 400 will be thrown.  Request will require the following legacy roles:  ORG_ADMIN and API
		     * @summary Overwrite the preferences for the given notification key.
		     * @param {NotificationsBetaApiPutNotificationPreferenceRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof NotificationsBetaApi
		     */
		    NotificationsBetaApi.prototype.putNotificationPreference = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.NotificationsBetaApiFp)(this.configuration).putNotificationPreference(requestParameters.key, requestParameters.preferencesDtoBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Send a Test Notification
		     * @summary Send Test Notification
		     * @param {NotificationsBetaApiSendTestNotificationRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof NotificationsBetaApi
		     */
		    NotificationsBetaApi.prototype.sendTestNotification = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.NotificationsBetaApiFp)(this.configuration).sendTestNotification(requestParameters.sendTestNotificationRequestDtoBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return NotificationsBetaApi;
		}(base_1.BaseAPI));
		exports.NotificationsBetaApi = NotificationsBetaApi;
		/**
		 * OAuthClientsBetaApi - axios parameter creator
		 * @export
		 */
		var OAuthClientsBetaApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * This creates an OAuth client.
		         * @summary Create OAuth Client
		         * @param {CreateOAuthClientRequestBeta} createOAuthClientRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createOauthClient: function (createOAuthClientRequestBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'createOAuthClientRequestBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('createOauthClient', 'createOAuthClientRequestBeta', createOAuthClientRequestBeta);
		                            localVarPath = "/oauth-clients";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(createOAuthClientRequestBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This deletes an OAuth client.
		         * @summary Delete OAuth Client
		         * @param {string} id The OAuth client id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteOauthClient: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('deleteOauthClient', 'id', id);
		                            localVarPath = "/oauth-clients/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'DELETE' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets details of an OAuth client.
		         * @summary Get OAuth Client
		         * @param {string} id The OAuth client id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getOauthClient: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getOauthClient', 'id', id);
		                            localVarPath = "/oauth-clients/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets a list of OAuth clients.
		         * @summary List OAuth Clients
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **lastUsed**: *le, isnull*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listOauthClients: function (filters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/oauth-clients";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This performs a targeted update to the field(s) of an OAuth client. Request will require a security scope of  - sp:oauth-client:manage
		         * @summary Patch OAuth Client
		         * @param {string} id The OAuth client id
		         * @param {Array<JsonPatchOperationBeta>} jsonPatchOperationBeta A list of OAuth client update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.  The following fields are patchable: * tenant * businessName * homepageUrl * name * description * accessTokenValiditySeconds * refreshTokenValiditySeconds * redirectUris * grantTypes * accessType * enabled * strongAuthSupported * claimsSupported
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchOauthClient: function (id, jsonPatchOperationBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('patchOauthClient', 'id', id);
		                            // verify required parameter 'jsonPatchOperationBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('patchOauthClient', 'jsonPatchOperationBeta', jsonPatchOperationBeta);
		                            localVarPath = "/oauth-clients/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PATCH' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json-patch+json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(jsonPatchOperationBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.OAuthClientsBetaApiAxiosParamCreator = OAuthClientsBetaApiAxiosParamCreator;
		/**
		 * OAuthClientsBetaApi - functional programming interface
		 * @export
		 */
		var OAuthClientsBetaApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.OAuthClientsBetaApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * This creates an OAuth client.
		         * @summary Create OAuth Client
		         * @param {CreateOAuthClientRequestBeta} createOAuthClientRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createOauthClient: function (createOAuthClientRequestBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.createOauthClient(createOAuthClientRequestBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This deletes an OAuth client.
		         * @summary Delete OAuth Client
		         * @param {string} id The OAuth client id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteOauthClient: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.deleteOauthClient(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets details of an OAuth client.
		         * @summary Get OAuth Client
		         * @param {string} id The OAuth client id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getOauthClient: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getOauthClient(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets a list of OAuth clients.
		         * @summary List OAuth Clients
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **lastUsed**: *le, isnull*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listOauthClients: function (filters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listOauthClients(filters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This performs a targeted update to the field(s) of an OAuth client. Request will require a security scope of  - sp:oauth-client:manage
		         * @summary Patch OAuth Client
		         * @param {string} id The OAuth client id
		         * @param {Array<JsonPatchOperationBeta>} jsonPatchOperationBeta A list of OAuth client update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.  The following fields are patchable: * tenant * businessName * homepageUrl * name * description * accessTokenValiditySeconds * refreshTokenValiditySeconds * redirectUris * grantTypes * accessType * enabled * strongAuthSupported * claimsSupported
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchOauthClient: function (id, jsonPatchOperationBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.patchOauthClient(id, jsonPatchOperationBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.OAuthClientsBetaApiFp = OAuthClientsBetaApiFp;
		/**
		 * OAuthClientsBetaApi - factory interface
		 * @export
		 */
		var OAuthClientsBetaApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.OAuthClientsBetaApiFp)(configuration);
		    return {
		        /**
		         * This creates an OAuth client.
		         * @summary Create OAuth Client
		         * @param {CreateOAuthClientRequestBeta} createOAuthClientRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createOauthClient: function (createOAuthClientRequestBeta, axiosOptions) {
		            return localVarFp.createOauthClient(createOAuthClientRequestBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This deletes an OAuth client.
		         * @summary Delete OAuth Client
		         * @param {string} id The OAuth client id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteOauthClient: function (id, axiosOptions) {
		            return localVarFp.deleteOauthClient(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This gets details of an OAuth client.
		         * @summary Get OAuth Client
		         * @param {string} id The OAuth client id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getOauthClient: function (id, axiosOptions) {
		            return localVarFp.getOauthClient(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This gets a list of OAuth clients.
		         * @summary List OAuth Clients
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **lastUsed**: *le, isnull*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listOauthClients: function (filters, axiosOptions) {
		            return localVarFp.listOauthClients(filters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This performs a targeted update to the field(s) of an OAuth client. Request will require a security scope of  - sp:oauth-client:manage
		         * @summary Patch OAuth Client
		         * @param {string} id The OAuth client id
		         * @param {Array<JsonPatchOperationBeta>} jsonPatchOperationBeta A list of OAuth client update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.  The following fields are patchable: * tenant * businessName * homepageUrl * name * description * accessTokenValiditySeconds * refreshTokenValiditySeconds * redirectUris * grantTypes * accessType * enabled * strongAuthSupported * claimsSupported
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchOauthClient: function (id, jsonPatchOperationBeta, axiosOptions) {
		            return localVarFp.patchOauthClient(id, jsonPatchOperationBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.OAuthClientsBetaApiFactory = OAuthClientsBetaApiFactory;
		/**
		 * OAuthClientsBetaApi - object-oriented interface
		 * @export
		 * @class OAuthClientsBetaApi
		 * @extends {BaseAPI}
		 */
		var OAuthClientsBetaApi = /** @class */ (function (_super) {
		    __extends(OAuthClientsBetaApi, _super);
		    function OAuthClientsBetaApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * This creates an OAuth client.
		     * @summary Create OAuth Client
		     * @param {OAuthClientsBetaApiCreateOauthClientRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof OAuthClientsBetaApi
		     */
		    OAuthClientsBetaApi.prototype.createOauthClient = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.OAuthClientsBetaApiFp)(this.configuration).createOauthClient(requestParameters.createOAuthClientRequestBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This deletes an OAuth client.
		     * @summary Delete OAuth Client
		     * @param {OAuthClientsBetaApiDeleteOauthClientRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof OAuthClientsBetaApi
		     */
		    OAuthClientsBetaApi.prototype.deleteOauthClient = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.OAuthClientsBetaApiFp)(this.configuration).deleteOauthClient(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This gets details of an OAuth client.
		     * @summary Get OAuth Client
		     * @param {OAuthClientsBetaApiGetOauthClientRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof OAuthClientsBetaApi
		     */
		    OAuthClientsBetaApi.prototype.getOauthClient = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.OAuthClientsBetaApiFp)(this.configuration).getOauthClient(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This gets a list of OAuth clients.
		     * @summary List OAuth Clients
		     * @param {OAuthClientsBetaApiListOauthClientsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof OAuthClientsBetaApi
		     */
		    OAuthClientsBetaApi.prototype.listOauthClients = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.OAuthClientsBetaApiFp)(this.configuration).listOauthClients(requestParameters.filters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This performs a targeted update to the field(s) of an OAuth client. Request will require a security scope of  - sp:oauth-client:manage
		     * @summary Patch OAuth Client
		     * @param {OAuthClientsBetaApiPatchOauthClientRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof OAuthClientsBetaApi
		     */
		    OAuthClientsBetaApi.prototype.patchOauthClient = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.OAuthClientsBetaApiFp)(this.configuration).patchOauthClient(requestParameters.id, requestParameters.jsonPatchOperationBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return OAuthClientsBetaApi;
		}(base_1.BaseAPI));
		exports.OAuthClientsBetaApi = OAuthClientsBetaApi;
		/**
		 * OrgConfigBetaApi - axios parameter creator
		 * @export
		 */
		var OrgConfigBetaApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * Get org configuration with only external (org admin) accessible properties for the current org.
		         * @summary Get Org configuration settings
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getOrgConfig: function (axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/org-config";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Get a list of valid time zones that can be set in org configurations.
		         * @summary Get list of time zones
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getValidTimeZones: function (axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/org-config/valid-time-zones";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Patch configuration of the current org using http://jsonpatch.com/ syntax.  Commonly used for changing the time zone of an org.
		         * @summary Patch an Org configuration property
		         * @param {Array<JsonPatchOperationBeta>} jsonPatchOperationBeta A list of schema attribute update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchOrgConfig: function (jsonPatchOperationBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'jsonPatchOperationBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('patchOrgConfig', 'jsonPatchOperationBeta', jsonPatchOperationBeta);
		                            localVarPath = "/org-config";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PATCH' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json-patch+json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(jsonPatchOperationBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.OrgConfigBetaApiAxiosParamCreator = OrgConfigBetaApiAxiosParamCreator;
		/**
		 * OrgConfigBetaApi - functional programming interface
		 * @export
		 */
		var OrgConfigBetaApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.OrgConfigBetaApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * Get org configuration with only external (org admin) accessible properties for the current org.
		         * @summary Get Org configuration settings
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getOrgConfig: function (axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getOrgConfig(axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Get a list of valid time zones that can be set in org configurations.
		         * @summary Get list of time zones
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getValidTimeZones: function (axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getValidTimeZones(axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Patch configuration of the current org using http://jsonpatch.com/ syntax.  Commonly used for changing the time zone of an org.
		         * @summary Patch an Org configuration property
		         * @param {Array<JsonPatchOperationBeta>} jsonPatchOperationBeta A list of schema attribute update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchOrgConfig: function (jsonPatchOperationBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.patchOrgConfig(jsonPatchOperationBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.OrgConfigBetaApiFp = OrgConfigBetaApiFp;
		/**
		 * OrgConfigBetaApi - factory interface
		 * @export
		 */
		var OrgConfigBetaApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.OrgConfigBetaApiFp)(configuration);
		    return {
		        /**
		         * Get org configuration with only external (org admin) accessible properties for the current org.
		         * @summary Get Org configuration settings
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getOrgConfig: function (axiosOptions) {
		            return localVarFp.getOrgConfig(axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Get a list of valid time zones that can be set in org configurations.
		         * @summary Get list of time zones
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getValidTimeZones: function (axiosOptions) {
		            return localVarFp.getValidTimeZones(axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Patch configuration of the current org using http://jsonpatch.com/ syntax.  Commonly used for changing the time zone of an org.
		         * @summary Patch an Org configuration property
		         * @param {Array<JsonPatchOperationBeta>} jsonPatchOperationBeta A list of schema attribute update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchOrgConfig: function (jsonPatchOperationBeta, axiosOptions) {
		            return localVarFp.patchOrgConfig(jsonPatchOperationBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.OrgConfigBetaApiFactory = OrgConfigBetaApiFactory;
		/**
		 * OrgConfigBetaApi - object-oriented interface
		 * @export
		 * @class OrgConfigBetaApi
		 * @extends {BaseAPI}
		 */
		var OrgConfigBetaApi = /** @class */ (function (_super) {
		    __extends(OrgConfigBetaApi, _super);
		    function OrgConfigBetaApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * Get org configuration with only external (org admin) accessible properties for the current org.
		     * @summary Get Org configuration settings
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof OrgConfigBetaApi
		     */
		    OrgConfigBetaApi.prototype.getOrgConfig = function (axiosOptions) {
		        var _this = this;
		        return (0, exports.OrgConfigBetaApiFp)(this.configuration).getOrgConfig(axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Get a list of valid time zones that can be set in org configurations.
		     * @summary Get list of time zones
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof OrgConfigBetaApi
		     */
		    OrgConfigBetaApi.prototype.getValidTimeZones = function (axiosOptions) {
		        var _this = this;
		        return (0, exports.OrgConfigBetaApiFp)(this.configuration).getValidTimeZones(axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Patch configuration of the current org using http://jsonpatch.com/ syntax.  Commonly used for changing the time zone of an org.
		     * @summary Patch an Org configuration property
		     * @param {OrgConfigBetaApiPatchOrgConfigRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof OrgConfigBetaApi
		     */
		    OrgConfigBetaApi.prototype.patchOrgConfig = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.OrgConfigBetaApiFp)(this.configuration).patchOrgConfig(requestParameters.jsonPatchOperationBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return OrgConfigBetaApi;
		}(base_1.BaseAPI));
		exports.OrgConfigBetaApi = OrgConfigBetaApi;
		/**
		 * PasswordConfigurationBetaApi - axios parameter creator
		 * @export
		 */
		var PasswordConfigurationBetaApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * This API creates the password org config. Unspecified fields will use default value. To be able to use the custom password instructions, you must set the `customInstructionsEnabled` field to \"true\". Requires ORG_ADMIN, API role or authorization scope of \'idn:password-org-config:write\'
		         * @summary Create Password Org Config
		         * @param {PasswordOrgConfigBeta} passwordOrgConfigBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createPasswordOrgConfig: function (passwordOrgConfigBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'passwordOrgConfigBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('createPasswordOrgConfig', 'passwordOrgConfigBeta', passwordOrgConfigBeta);
		                            localVarPath = "/password-org-config";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(passwordOrgConfigBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns the password org config . Requires ORG_ADMIN, API role or authorization scope of \'idn:password-org-config:read\'
		         * @summary Get Password Org Config
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getPasswordOrgConfig: function (axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/password-org-config";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API updates the password org config for specified fields. Other fields will keep original value. You must set the `customInstructionsEnabled` field to \"true\" to be able to use custom password instructions.  Requires ORG_ADMIN, API role or authorization scope of \'idn:password-org-config:write\'
		         * @summary Update Password Org Config
		         * @param {PasswordOrgConfigBeta} passwordOrgConfigBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putPasswordOrgConfig: function (passwordOrgConfigBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'passwordOrgConfigBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('putPasswordOrgConfig', 'passwordOrgConfigBeta', passwordOrgConfigBeta);
		                            localVarPath = "/password-org-config";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PUT' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(passwordOrgConfigBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.PasswordConfigurationBetaApiAxiosParamCreator = PasswordConfigurationBetaApiAxiosParamCreator;
		/**
		 * PasswordConfigurationBetaApi - functional programming interface
		 * @export
		 */
		var PasswordConfigurationBetaApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.PasswordConfigurationBetaApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * This API creates the password org config. Unspecified fields will use default value. To be able to use the custom password instructions, you must set the `customInstructionsEnabled` field to \"true\". Requires ORG_ADMIN, API role or authorization scope of \'idn:password-org-config:write\'
		         * @summary Create Password Org Config
		         * @param {PasswordOrgConfigBeta} passwordOrgConfigBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createPasswordOrgConfig: function (passwordOrgConfigBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.createPasswordOrgConfig(passwordOrgConfigBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns the password org config . Requires ORG_ADMIN, API role or authorization scope of \'idn:password-org-config:read\'
		         * @summary Get Password Org Config
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getPasswordOrgConfig: function (axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getPasswordOrgConfig(axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API updates the password org config for specified fields. Other fields will keep original value. You must set the `customInstructionsEnabled` field to \"true\" to be able to use custom password instructions.  Requires ORG_ADMIN, API role or authorization scope of \'idn:password-org-config:write\'
		         * @summary Update Password Org Config
		         * @param {PasswordOrgConfigBeta} passwordOrgConfigBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putPasswordOrgConfig: function (passwordOrgConfigBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.putPasswordOrgConfig(passwordOrgConfigBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.PasswordConfigurationBetaApiFp = PasswordConfigurationBetaApiFp;
		/**
		 * PasswordConfigurationBetaApi - factory interface
		 * @export
		 */
		var PasswordConfigurationBetaApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.PasswordConfigurationBetaApiFp)(configuration);
		    return {
		        /**
		         * This API creates the password org config. Unspecified fields will use default value. To be able to use the custom password instructions, you must set the `customInstructionsEnabled` field to \"true\". Requires ORG_ADMIN, API role or authorization scope of \'idn:password-org-config:write\'
		         * @summary Create Password Org Config
		         * @param {PasswordOrgConfigBeta} passwordOrgConfigBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createPasswordOrgConfig: function (passwordOrgConfigBeta, axiosOptions) {
		            return localVarFp.createPasswordOrgConfig(passwordOrgConfigBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API returns the password org config . Requires ORG_ADMIN, API role or authorization scope of \'idn:password-org-config:read\'
		         * @summary Get Password Org Config
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getPasswordOrgConfig: function (axiosOptions) {
		            return localVarFp.getPasswordOrgConfig(axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API updates the password org config for specified fields. Other fields will keep original value. You must set the `customInstructionsEnabled` field to \"true\" to be able to use custom password instructions.  Requires ORG_ADMIN, API role or authorization scope of \'idn:password-org-config:write\'
		         * @summary Update Password Org Config
		         * @param {PasswordOrgConfigBeta} passwordOrgConfigBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putPasswordOrgConfig: function (passwordOrgConfigBeta, axiosOptions) {
		            return localVarFp.putPasswordOrgConfig(passwordOrgConfigBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.PasswordConfigurationBetaApiFactory = PasswordConfigurationBetaApiFactory;
		/**
		 * PasswordConfigurationBetaApi - object-oriented interface
		 * @export
		 * @class PasswordConfigurationBetaApi
		 * @extends {BaseAPI}
		 */
		var PasswordConfigurationBetaApi = /** @class */ (function (_super) {
		    __extends(PasswordConfigurationBetaApi, _super);
		    function PasswordConfigurationBetaApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * This API creates the password org config. Unspecified fields will use default value. To be able to use the custom password instructions, you must set the `customInstructionsEnabled` field to \"true\". Requires ORG_ADMIN, API role or authorization scope of \'idn:password-org-config:write\'
		     * @summary Create Password Org Config
		     * @param {PasswordConfigurationBetaApiCreatePasswordOrgConfigRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof PasswordConfigurationBetaApi
		     */
		    PasswordConfigurationBetaApi.prototype.createPasswordOrgConfig = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.PasswordConfigurationBetaApiFp)(this.configuration).createPasswordOrgConfig(requestParameters.passwordOrgConfigBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API returns the password org config . Requires ORG_ADMIN, API role or authorization scope of \'idn:password-org-config:read\'
		     * @summary Get Password Org Config
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof PasswordConfigurationBetaApi
		     */
		    PasswordConfigurationBetaApi.prototype.getPasswordOrgConfig = function (axiosOptions) {
		        var _this = this;
		        return (0, exports.PasswordConfigurationBetaApiFp)(this.configuration).getPasswordOrgConfig(axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API updates the password org config for specified fields. Other fields will keep original value. You must set the `customInstructionsEnabled` field to \"true\" to be able to use custom password instructions.  Requires ORG_ADMIN, API role or authorization scope of \'idn:password-org-config:write\'
		     * @summary Update Password Org Config
		     * @param {PasswordConfigurationBetaApiPutPasswordOrgConfigRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof PasswordConfigurationBetaApi
		     */
		    PasswordConfigurationBetaApi.prototype.putPasswordOrgConfig = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.PasswordConfigurationBetaApiFp)(this.configuration).putPasswordOrgConfig(requestParameters.passwordOrgConfigBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return PasswordConfigurationBetaApi;
		}(base_1.BaseAPI));
		exports.PasswordConfigurationBetaApi = PasswordConfigurationBetaApi;
		/**
		 * PasswordDictionaryBetaApi - axios parameter creator
		 * @export
		 */
		var PasswordDictionaryBetaApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * This gets password dictionary for the organization. A token with ORG_ADMIN authority is required to call this API. The password dictionary file can contain lines that are: 1. comment lines - the first character is \'#\', can be 128 Unicode codepoints in length, and are ignored during processing 2. empty lines 3. locale line - the first line that starts with \"locale=\" is considered to be locale line, the rest are treated as normal content lines 4. line containing the password dictionary word - it must start with non-whitespace character and only non-whitespace characters are allowed;         maximum length of the line is 128 Unicode codepoints   Password dictionary file may not contain more than 2,500 lines (not counting whitespace lines, comment lines and locale line).   Password dict file must contain UTF-8 characters only.  # Sample password text file  ```  # Password dictionary small test file  locale=en_US  # Password dictionary prohibited words  qwerty abcd aaaaa password qazxsws  ```
		         * @summary Get Password Dictionary
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getPasswordDictionary: function (axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/password-dictionary";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This updates password dictionary for the organization. A token with ORG_ADMIN authority is required to call this API. The password dictionary file can contain lines that are: 1. comment lines - the first character is \'#\', can be 128 Unicode codepoints in length, and are ignored during processing 2. empty lines 3. locale line - the first line that starts with \"locale=\" is considered to be locale line, the rest are treated as normal content lines 4. line containing the password dictionary word - it must start with non-whitespace character and only non-whitespace characters are allowed;         maximum length of the line is 128 Unicode codepoints   Password dictionary file may not contain more than 2,500 lines (not counting whitespace lines, comment lines and locale line).   Password dict file must contain UTF-8 characters only.  # Sample password text file  ```  # Password dictionary small test file  locale=en_US  # Password dictionary prohibited words  qwerty abcd aaaaa password qazxsws  ```
		         * @summary Update Password Dictionary
		         * @param {any} [file]
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putPasswordDictionary: function (file, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, localVarFormParams, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/password-dictionary";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PUT' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            localVarFormParams = new ((configuration && configuration.formDataCtor) || FormData)();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (file !== undefined) {
		                                localVarFormParams.append('file', file);
		                            }
		                            localVarHeaderParameter['Content-Type'] = 'multipart/form-data';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = localVarFormParams;
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.PasswordDictionaryBetaApiAxiosParamCreator = PasswordDictionaryBetaApiAxiosParamCreator;
		/**
		 * PasswordDictionaryBetaApi - functional programming interface
		 * @export
		 */
		var PasswordDictionaryBetaApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.PasswordDictionaryBetaApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * This gets password dictionary for the organization. A token with ORG_ADMIN authority is required to call this API. The password dictionary file can contain lines that are: 1. comment lines - the first character is \'#\', can be 128 Unicode codepoints in length, and are ignored during processing 2. empty lines 3. locale line - the first line that starts with \"locale=\" is considered to be locale line, the rest are treated as normal content lines 4. line containing the password dictionary word - it must start with non-whitespace character and only non-whitespace characters are allowed;         maximum length of the line is 128 Unicode codepoints   Password dictionary file may not contain more than 2,500 lines (not counting whitespace lines, comment lines and locale line).   Password dict file must contain UTF-8 characters only.  # Sample password text file  ```  # Password dictionary small test file  locale=en_US  # Password dictionary prohibited words  qwerty abcd aaaaa password qazxsws  ```
		         * @summary Get Password Dictionary
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getPasswordDictionary: function (axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getPasswordDictionary(axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This updates password dictionary for the organization. A token with ORG_ADMIN authority is required to call this API. The password dictionary file can contain lines that are: 1. comment lines - the first character is \'#\', can be 128 Unicode codepoints in length, and are ignored during processing 2. empty lines 3. locale line - the first line that starts with \"locale=\" is considered to be locale line, the rest are treated as normal content lines 4. line containing the password dictionary word - it must start with non-whitespace character and only non-whitespace characters are allowed;         maximum length of the line is 128 Unicode codepoints   Password dictionary file may not contain more than 2,500 lines (not counting whitespace lines, comment lines and locale line).   Password dict file must contain UTF-8 characters only.  # Sample password text file  ```  # Password dictionary small test file  locale=en_US  # Password dictionary prohibited words  qwerty abcd aaaaa password qazxsws  ```
		         * @summary Update Password Dictionary
		         * @param {any} [file]
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putPasswordDictionary: function (file, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.putPasswordDictionary(file, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.PasswordDictionaryBetaApiFp = PasswordDictionaryBetaApiFp;
		/**
		 * PasswordDictionaryBetaApi - factory interface
		 * @export
		 */
		var PasswordDictionaryBetaApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.PasswordDictionaryBetaApiFp)(configuration);
		    return {
		        /**
		         * This gets password dictionary for the organization. A token with ORG_ADMIN authority is required to call this API. The password dictionary file can contain lines that are: 1. comment lines - the first character is \'#\', can be 128 Unicode codepoints in length, and are ignored during processing 2. empty lines 3. locale line - the first line that starts with \"locale=\" is considered to be locale line, the rest are treated as normal content lines 4. line containing the password dictionary word - it must start with non-whitespace character and only non-whitespace characters are allowed;         maximum length of the line is 128 Unicode codepoints   Password dictionary file may not contain more than 2,500 lines (not counting whitespace lines, comment lines and locale line).   Password dict file must contain UTF-8 characters only.  # Sample password text file  ```  # Password dictionary small test file  locale=en_US  # Password dictionary prohibited words  qwerty abcd aaaaa password qazxsws  ```
		         * @summary Get Password Dictionary
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getPasswordDictionary: function (axiosOptions) {
		            return localVarFp.getPasswordDictionary(axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This updates password dictionary for the organization. A token with ORG_ADMIN authority is required to call this API. The password dictionary file can contain lines that are: 1. comment lines - the first character is \'#\', can be 128 Unicode codepoints in length, and are ignored during processing 2. empty lines 3. locale line - the first line that starts with \"locale=\" is considered to be locale line, the rest are treated as normal content lines 4. line containing the password dictionary word - it must start with non-whitespace character and only non-whitespace characters are allowed;         maximum length of the line is 128 Unicode codepoints   Password dictionary file may not contain more than 2,500 lines (not counting whitespace lines, comment lines and locale line).   Password dict file must contain UTF-8 characters only.  # Sample password text file  ```  # Password dictionary small test file  locale=en_US  # Password dictionary prohibited words  qwerty abcd aaaaa password qazxsws  ```
		         * @summary Update Password Dictionary
		         * @param {any} [file]
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putPasswordDictionary: function (file, axiosOptions) {
		            return localVarFp.putPasswordDictionary(file, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.PasswordDictionaryBetaApiFactory = PasswordDictionaryBetaApiFactory;
		/**
		 * PasswordDictionaryBetaApi - object-oriented interface
		 * @export
		 * @class PasswordDictionaryBetaApi
		 * @extends {BaseAPI}
		 */
		var PasswordDictionaryBetaApi = /** @class */ (function (_super) {
		    __extends(PasswordDictionaryBetaApi, _super);
		    function PasswordDictionaryBetaApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * This gets password dictionary for the organization. A token with ORG_ADMIN authority is required to call this API. The password dictionary file can contain lines that are: 1. comment lines - the first character is \'#\', can be 128 Unicode codepoints in length, and are ignored during processing 2. empty lines 3. locale line - the first line that starts with \"locale=\" is considered to be locale line, the rest are treated as normal content lines 4. line containing the password dictionary word - it must start with non-whitespace character and only non-whitespace characters are allowed;         maximum length of the line is 128 Unicode codepoints   Password dictionary file may not contain more than 2,500 lines (not counting whitespace lines, comment lines and locale line).   Password dict file must contain UTF-8 characters only.  # Sample password text file  ```  # Password dictionary small test file  locale=en_US  # Password dictionary prohibited words  qwerty abcd aaaaa password qazxsws  ```
		     * @summary Get Password Dictionary
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof PasswordDictionaryBetaApi
		     */
		    PasswordDictionaryBetaApi.prototype.getPasswordDictionary = function (axiosOptions) {
		        var _this = this;
		        return (0, exports.PasswordDictionaryBetaApiFp)(this.configuration).getPasswordDictionary(axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This updates password dictionary for the organization. A token with ORG_ADMIN authority is required to call this API. The password dictionary file can contain lines that are: 1. comment lines - the first character is \'#\', can be 128 Unicode codepoints in length, and are ignored during processing 2. empty lines 3. locale line - the first line that starts with \"locale=\" is considered to be locale line, the rest are treated as normal content lines 4. line containing the password dictionary word - it must start with non-whitespace character and only non-whitespace characters are allowed;         maximum length of the line is 128 Unicode codepoints   Password dictionary file may not contain more than 2,500 lines (not counting whitespace lines, comment lines and locale line).   Password dict file must contain UTF-8 characters only.  # Sample password text file  ```  # Password dictionary small test file  locale=en_US  # Password dictionary prohibited words  qwerty abcd aaaaa password qazxsws  ```
		     * @summary Update Password Dictionary
		     * @param {PasswordDictionaryBetaApiPutPasswordDictionaryRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof PasswordDictionaryBetaApi
		     */
		    PasswordDictionaryBetaApi.prototype.putPasswordDictionary = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.PasswordDictionaryBetaApiFp)(this.configuration).putPasswordDictionary(requestParameters.file, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return PasswordDictionaryBetaApi;
		}(base_1.BaseAPI));
		exports.PasswordDictionaryBetaApi = PasswordDictionaryBetaApi;
		/**
		 * PasswordManagementBetaApi - axios parameter creator
		 * @export
		 */
		var PasswordManagementBetaApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * This API is used to generate a digit token for password management. Requires authorization scope of \"idn:password-digit-token:create\".
		         * @summary Generate a digit token
		         * @param {PasswordDigitTokenResetBeta} passwordDigitTokenResetBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        generateDigitToken: function (passwordDigitTokenResetBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'passwordDigitTokenResetBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('generateDigitToken', 'passwordDigitTokenResetBeta', passwordDigitTokenResetBeta);
		                            localVarPath = "/generate-password-reset-token/digit";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(passwordDigitTokenResetBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns the status of a password change request. A token with identity owner or trusted API client application authority is required to call this API.
		         * @summary Get Password Change Request Status
		         * @param {string} id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getIdentityPasswordChangeStatus: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getIdentityPasswordChangeStatus', 'id', id);
		                            localVarPath = "/password-change-status/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API is used to query password related information.   A token with [API authority](https://developer.sailpoint.com/idn/api/authentication#client-credentials-grant-flow)  is required to call this API.  \"API authority\" refers to a token that only has the \"client_credentials\"  grant type, and therefore no user context. A [personal access token](https://developer.sailpoint.com/idn/api/authentication#personal-access-tokens)  or a token generated with the [authorization_code](https://developer.sailpoint.com/idn/api/authentication#authorization-code-grant-flow)  grant type will **NOT** work on this endpoint, and a `403 Forbidden` response  will be returned.
		         * @summary Query Password Info
		         * @param {PasswordInfoQueryDTOBeta} passwordInfoQueryDTOBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        queryPasswordInfo: function (passwordInfoQueryDTOBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'passwordInfoQueryDTOBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('queryPasswordInfo', 'passwordInfoQueryDTOBeta', passwordInfoQueryDTOBeta);
		                            localVarPath = "/query-password-info";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(passwordInfoQueryDTOBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API is used to set a password for an identity.   An identity can change their own password (as well as any of their accounts\' passwords) if they use a token generated by their IDN user, such as a [personal access token](https://developer.sailpoint.com/idn/api/authentication#personal-access-tokens) or [\"authorization_code\" derived OAuth token](https://developer.sailpoint.com/idn/api/authentication#authorization-code-grant-flow).  A token with [API authority](https://developer.sailpoint.com/idn/api/authentication#client-credentials-grant-flow) can be used to change **any** identity\'s password or the password of any of the identity\'s accounts.  \"API authority\" refers to a token that only has the \"client_credentials\" grant type.  You can use this endpoint to generate an `encryptedPassword` (RSA encrypted using publicKey).  To do so, follow these steps:  1. Use [Query Password Info](https://developer.sailpoint.com/idn/api/v3/query-password-info) to get the following information: `identityId`, `sourceId`, `publicKeyId`, `publicKey`, `accounts`, and `policies`.   2. Choose an account from the previous response that you will provide as an `accountId` in your request to set an encrypted password.   3. Use [Set Identity\'s Password](https://developer.sailpoint.com/idn/api/v3/set-password) and provide the information you got from your earlier query. Then add this code to your request to get the encrypted password:  ```java import javax.crypto.Cipher; import java.security.KeyFactory; import java.security.PublicKey; import java.security.spec.X509EncodedKeySpec; import java util.Base64;  String encrypt(String publicKey, String toEncrypt) throws Exception {   byte[] publicKeyBytes = Base64.getDecoder().decode(publicKey);   byte[] encryptedBytes = encryptRsa(publicKeyBytes, toEncrypt.getBytes(\"UTF-8\"));   return Base64.getEncoder().encodeToString(encryptedBytes); }  private byte[] encryptRsa(byte[] publicKeyBytes, byte[] toEncryptBytes) throws Exception {   PublicKey key = KeyFactory.getInstance(\"RSA\").generatePublic(new X509EncodedKeySpec(publicKeyBytes));   String transformation = \"RSA/ECB/PKCS1Padding\";   Cipher cipher = Cipher.getInstance(transformation);   cipher.init(1, key);   return cipher.doFinal(toEncryptBytes); } ```      In this example, `toEncrypt` refers to the plain text password you are setting and then encrypting, and the `publicKey` refers to the publicKey you got from the first request you sent.   You can then use [Get Password Change Request Status](https://developer.sailpoint.com/idn/api/v3/get-password-change-status) to check the password change request status. To do so, you must provide the `requestId` from your earlier request to set the password.
		         * @summary Set Identity\'s Password
		         * @param {PasswordChangeRequestBeta} passwordChangeRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        setIdentityPassword: function (passwordChangeRequestBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'passwordChangeRequestBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('setIdentityPassword', 'passwordChangeRequestBeta', passwordChangeRequestBeta);
		                            localVarPath = "/set-password";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(passwordChangeRequestBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.PasswordManagementBetaApiAxiosParamCreator = PasswordManagementBetaApiAxiosParamCreator;
		/**
		 * PasswordManagementBetaApi - functional programming interface
		 * @export
		 */
		var PasswordManagementBetaApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.PasswordManagementBetaApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * This API is used to generate a digit token for password management. Requires authorization scope of \"idn:password-digit-token:create\".
		         * @summary Generate a digit token
		         * @param {PasswordDigitTokenResetBeta} passwordDigitTokenResetBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        generateDigitToken: function (passwordDigitTokenResetBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.generateDigitToken(passwordDigitTokenResetBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns the status of a password change request. A token with identity owner or trusted API client application authority is required to call this API.
		         * @summary Get Password Change Request Status
		         * @param {string} id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getIdentityPasswordChangeStatus: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getIdentityPasswordChangeStatus(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API is used to query password related information.   A token with [API authority](https://developer.sailpoint.com/idn/api/authentication#client-credentials-grant-flow)  is required to call this API.  \"API authority\" refers to a token that only has the \"client_credentials\"  grant type, and therefore no user context. A [personal access token](https://developer.sailpoint.com/idn/api/authentication#personal-access-tokens)  or a token generated with the [authorization_code](https://developer.sailpoint.com/idn/api/authentication#authorization-code-grant-flow)  grant type will **NOT** work on this endpoint, and a `403 Forbidden` response  will be returned.
		         * @summary Query Password Info
		         * @param {PasswordInfoQueryDTOBeta} passwordInfoQueryDTOBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        queryPasswordInfo: function (passwordInfoQueryDTOBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.queryPasswordInfo(passwordInfoQueryDTOBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API is used to set a password for an identity.   An identity can change their own password (as well as any of their accounts\' passwords) if they use a token generated by their IDN user, such as a [personal access token](https://developer.sailpoint.com/idn/api/authentication#personal-access-tokens) or [\"authorization_code\" derived OAuth token](https://developer.sailpoint.com/idn/api/authentication#authorization-code-grant-flow).  A token with [API authority](https://developer.sailpoint.com/idn/api/authentication#client-credentials-grant-flow) can be used to change **any** identity\'s password or the password of any of the identity\'s accounts.  \"API authority\" refers to a token that only has the \"client_credentials\" grant type.  You can use this endpoint to generate an `encryptedPassword` (RSA encrypted using publicKey).  To do so, follow these steps:  1. Use [Query Password Info](https://developer.sailpoint.com/idn/api/v3/query-password-info) to get the following information: `identityId`, `sourceId`, `publicKeyId`, `publicKey`, `accounts`, and `policies`.   2. Choose an account from the previous response that you will provide as an `accountId` in your request to set an encrypted password.   3. Use [Set Identity\'s Password](https://developer.sailpoint.com/idn/api/v3/set-password) and provide the information you got from your earlier query. Then add this code to your request to get the encrypted password:  ```java import javax.crypto.Cipher; import java.security.KeyFactory; import java.security.PublicKey; import java.security.spec.X509EncodedKeySpec; import java util.Base64;  String encrypt(String publicKey, String toEncrypt) throws Exception {   byte[] publicKeyBytes = Base64.getDecoder().decode(publicKey);   byte[] encryptedBytes = encryptRsa(publicKeyBytes, toEncrypt.getBytes(\"UTF-8\"));   return Base64.getEncoder().encodeToString(encryptedBytes); }  private byte[] encryptRsa(byte[] publicKeyBytes, byte[] toEncryptBytes) throws Exception {   PublicKey key = KeyFactory.getInstance(\"RSA\").generatePublic(new X509EncodedKeySpec(publicKeyBytes));   String transformation = \"RSA/ECB/PKCS1Padding\";   Cipher cipher = Cipher.getInstance(transformation);   cipher.init(1, key);   return cipher.doFinal(toEncryptBytes); } ```      In this example, `toEncrypt` refers to the plain text password you are setting and then encrypting, and the `publicKey` refers to the publicKey you got from the first request you sent.   You can then use [Get Password Change Request Status](https://developer.sailpoint.com/idn/api/v3/get-password-change-status) to check the password change request status. To do so, you must provide the `requestId` from your earlier request to set the password.
		         * @summary Set Identity\'s Password
		         * @param {PasswordChangeRequestBeta} passwordChangeRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        setIdentityPassword: function (passwordChangeRequestBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.setIdentityPassword(passwordChangeRequestBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.PasswordManagementBetaApiFp = PasswordManagementBetaApiFp;
		/**
		 * PasswordManagementBetaApi - factory interface
		 * @export
		 */
		var PasswordManagementBetaApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.PasswordManagementBetaApiFp)(configuration);
		    return {
		        /**
		         * This API is used to generate a digit token for password management. Requires authorization scope of \"idn:password-digit-token:create\".
		         * @summary Generate a digit token
		         * @param {PasswordDigitTokenResetBeta} passwordDigitTokenResetBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        generateDigitToken: function (passwordDigitTokenResetBeta, axiosOptions) {
		            return localVarFp.generateDigitToken(passwordDigitTokenResetBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API returns the status of a password change request. A token with identity owner or trusted API client application authority is required to call this API.
		         * @summary Get Password Change Request Status
		         * @param {string} id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getIdentityPasswordChangeStatus: function (id, axiosOptions) {
		            return localVarFp.getIdentityPasswordChangeStatus(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API is used to query password related information.   A token with [API authority](https://developer.sailpoint.com/idn/api/authentication#client-credentials-grant-flow)  is required to call this API.  \"API authority\" refers to a token that only has the \"client_credentials\"  grant type, and therefore no user context. A [personal access token](https://developer.sailpoint.com/idn/api/authentication#personal-access-tokens)  or a token generated with the [authorization_code](https://developer.sailpoint.com/idn/api/authentication#authorization-code-grant-flow)  grant type will **NOT** work on this endpoint, and a `403 Forbidden` response  will be returned.
		         * @summary Query Password Info
		         * @param {PasswordInfoQueryDTOBeta} passwordInfoQueryDTOBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        queryPasswordInfo: function (passwordInfoQueryDTOBeta, axiosOptions) {
		            return localVarFp.queryPasswordInfo(passwordInfoQueryDTOBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API is used to set a password for an identity.   An identity can change their own password (as well as any of their accounts\' passwords) if they use a token generated by their IDN user, such as a [personal access token](https://developer.sailpoint.com/idn/api/authentication#personal-access-tokens) or [\"authorization_code\" derived OAuth token](https://developer.sailpoint.com/idn/api/authentication#authorization-code-grant-flow).  A token with [API authority](https://developer.sailpoint.com/idn/api/authentication#client-credentials-grant-flow) can be used to change **any** identity\'s password or the password of any of the identity\'s accounts.  \"API authority\" refers to a token that only has the \"client_credentials\" grant type.  You can use this endpoint to generate an `encryptedPassword` (RSA encrypted using publicKey).  To do so, follow these steps:  1. Use [Query Password Info](https://developer.sailpoint.com/idn/api/v3/query-password-info) to get the following information: `identityId`, `sourceId`, `publicKeyId`, `publicKey`, `accounts`, and `policies`.   2. Choose an account from the previous response that you will provide as an `accountId` in your request to set an encrypted password.   3. Use [Set Identity\'s Password](https://developer.sailpoint.com/idn/api/v3/set-password) and provide the information you got from your earlier query. Then add this code to your request to get the encrypted password:  ```java import javax.crypto.Cipher; import java.security.KeyFactory; import java.security.PublicKey; import java.security.spec.X509EncodedKeySpec; import java util.Base64;  String encrypt(String publicKey, String toEncrypt) throws Exception {   byte[] publicKeyBytes = Base64.getDecoder().decode(publicKey);   byte[] encryptedBytes = encryptRsa(publicKeyBytes, toEncrypt.getBytes(\"UTF-8\"));   return Base64.getEncoder().encodeToString(encryptedBytes); }  private byte[] encryptRsa(byte[] publicKeyBytes, byte[] toEncryptBytes) throws Exception {   PublicKey key = KeyFactory.getInstance(\"RSA\").generatePublic(new X509EncodedKeySpec(publicKeyBytes));   String transformation = \"RSA/ECB/PKCS1Padding\";   Cipher cipher = Cipher.getInstance(transformation);   cipher.init(1, key);   return cipher.doFinal(toEncryptBytes); } ```      In this example, `toEncrypt` refers to the plain text password you are setting and then encrypting, and the `publicKey` refers to the publicKey you got from the first request you sent.   You can then use [Get Password Change Request Status](https://developer.sailpoint.com/idn/api/v3/get-password-change-status) to check the password change request status. To do so, you must provide the `requestId` from your earlier request to set the password.
		         * @summary Set Identity\'s Password
		         * @param {PasswordChangeRequestBeta} passwordChangeRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        setIdentityPassword: function (passwordChangeRequestBeta, axiosOptions) {
		            return localVarFp.setIdentityPassword(passwordChangeRequestBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.PasswordManagementBetaApiFactory = PasswordManagementBetaApiFactory;
		/**
		 * PasswordManagementBetaApi - object-oriented interface
		 * @export
		 * @class PasswordManagementBetaApi
		 * @extends {BaseAPI}
		 */
		var PasswordManagementBetaApi = /** @class */ (function (_super) {
		    __extends(PasswordManagementBetaApi, _super);
		    function PasswordManagementBetaApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * This API is used to generate a digit token for password management. Requires authorization scope of \"idn:password-digit-token:create\".
		     * @summary Generate a digit token
		     * @param {PasswordManagementBetaApiGenerateDigitTokenRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof PasswordManagementBetaApi
		     */
		    PasswordManagementBetaApi.prototype.generateDigitToken = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.PasswordManagementBetaApiFp)(this.configuration).generateDigitToken(requestParameters.passwordDigitTokenResetBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API returns the status of a password change request. A token with identity owner or trusted API client application authority is required to call this API.
		     * @summary Get Password Change Request Status
		     * @param {PasswordManagementBetaApiGetIdentityPasswordChangeStatusRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof PasswordManagementBetaApi
		     */
		    PasswordManagementBetaApi.prototype.getIdentityPasswordChangeStatus = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.PasswordManagementBetaApiFp)(this.configuration).getIdentityPasswordChangeStatus(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API is used to query password related information.   A token with [API authority](https://developer.sailpoint.com/idn/api/authentication#client-credentials-grant-flow)  is required to call this API.  \"API authority\" refers to a token that only has the \"client_credentials\"  grant type, and therefore no user context. A [personal access token](https://developer.sailpoint.com/idn/api/authentication#personal-access-tokens)  or a token generated with the [authorization_code](https://developer.sailpoint.com/idn/api/authentication#authorization-code-grant-flow)  grant type will **NOT** work on this endpoint, and a `403 Forbidden` response  will be returned.
		     * @summary Query Password Info
		     * @param {PasswordManagementBetaApiQueryPasswordInfoRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof PasswordManagementBetaApi
		     */
		    PasswordManagementBetaApi.prototype.queryPasswordInfo = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.PasswordManagementBetaApiFp)(this.configuration).queryPasswordInfo(requestParameters.passwordInfoQueryDTOBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API is used to set a password for an identity.   An identity can change their own password (as well as any of their accounts\' passwords) if they use a token generated by their IDN user, such as a [personal access token](https://developer.sailpoint.com/idn/api/authentication#personal-access-tokens) or [\"authorization_code\" derived OAuth token](https://developer.sailpoint.com/idn/api/authentication#authorization-code-grant-flow).  A token with [API authority](https://developer.sailpoint.com/idn/api/authentication#client-credentials-grant-flow) can be used to change **any** identity\'s password or the password of any of the identity\'s accounts.  \"API authority\" refers to a token that only has the \"client_credentials\" grant type.  You can use this endpoint to generate an `encryptedPassword` (RSA encrypted using publicKey).  To do so, follow these steps:  1. Use [Query Password Info](https://developer.sailpoint.com/idn/api/v3/query-password-info) to get the following information: `identityId`, `sourceId`, `publicKeyId`, `publicKey`, `accounts`, and `policies`.   2. Choose an account from the previous response that you will provide as an `accountId` in your request to set an encrypted password.   3. Use [Set Identity\'s Password](https://developer.sailpoint.com/idn/api/v3/set-password) and provide the information you got from your earlier query. Then add this code to your request to get the encrypted password:  ```java import javax.crypto.Cipher; import java.security.KeyFactory; import java.security.PublicKey; import java.security.spec.X509EncodedKeySpec; import java util.Base64;  String encrypt(String publicKey, String toEncrypt) throws Exception {   byte[] publicKeyBytes = Base64.getDecoder().decode(publicKey);   byte[] encryptedBytes = encryptRsa(publicKeyBytes, toEncrypt.getBytes(\"UTF-8\"));   return Base64.getEncoder().encodeToString(encryptedBytes); }  private byte[] encryptRsa(byte[] publicKeyBytes, byte[] toEncryptBytes) throws Exception {   PublicKey key = KeyFactory.getInstance(\"RSA\").generatePublic(new X509EncodedKeySpec(publicKeyBytes));   String transformation = \"RSA/ECB/PKCS1Padding\";   Cipher cipher = Cipher.getInstance(transformation);   cipher.init(1, key);   return cipher.doFinal(toEncryptBytes); } ```      In this example, `toEncrypt` refers to the plain text password you are setting and then encrypting, and the `publicKey` refers to the publicKey you got from the first request you sent.   You can then use [Get Password Change Request Status](https://developer.sailpoint.com/idn/api/v3/get-password-change-status) to check the password change request status. To do so, you must provide the `requestId` from your earlier request to set the password.
		     * @summary Set Identity\'s Password
		     * @param {PasswordManagementBetaApiSetIdentityPasswordRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof PasswordManagementBetaApi
		     */
		    PasswordManagementBetaApi.prototype.setIdentityPassword = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.PasswordManagementBetaApiFp)(this.configuration).setIdentityPassword(requestParameters.passwordChangeRequestBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return PasswordManagementBetaApi;
		}(base_1.BaseAPI));
		exports.PasswordManagementBetaApi = PasswordManagementBetaApi;
		/**
		 * PasswordSyncGroupsBetaApi - axios parameter creator
		 * @export
		 */
		var PasswordSyncGroupsBetaApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * This API creates a password sync group based on the specifications provided. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Create Password Sync Group
		         * @param {PasswordSyncGroupBeta} passwordSyncGroupBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createPasswordSyncGroup: function (passwordSyncGroupBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'passwordSyncGroupBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('createPasswordSyncGroup', 'passwordSyncGroupBeta', passwordSyncGroupBeta);
		                            localVarPath = "/password-sync-groups";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(passwordSyncGroupBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API deletes the specified password sync group. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Delete Password Sync Group by ID
		         * @param {string} id The ID of password sync group to delete.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deletePasswordSyncGroup: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('deletePasswordSyncGroup', 'id', id);
		                            localVarPath = "/password-sync-groups/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'DELETE' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns the sync group for the specified ID. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Get Password Sync Group by ID
		         * @param {string} id The ID of password sync group to retrieve.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getPasswordSyncGroup: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getPasswordSyncGroup', 'id', id);
		                            localVarPath = "/password-sync-groups/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns a list of password sync groups. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Get Password Sync Group List
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getPasswordSyncGroups: function (limit, offset, count, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/password-sync-groups";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API updates the specified password sync group. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Update Password Sync Group by ID
		         * @param {string} id The ID of password sync group to update.
		         * @param {PasswordSyncGroupBeta} passwordSyncGroupBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updatePasswordSyncGroup: function (id, passwordSyncGroupBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('updatePasswordSyncGroup', 'id', id);
		                            // verify required parameter 'passwordSyncGroupBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('updatePasswordSyncGroup', 'passwordSyncGroupBeta', passwordSyncGroupBeta);
		                            localVarPath = "/password-sync-groups/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PUT' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(passwordSyncGroupBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.PasswordSyncGroupsBetaApiAxiosParamCreator = PasswordSyncGroupsBetaApiAxiosParamCreator;
		/**
		 * PasswordSyncGroupsBetaApi - functional programming interface
		 * @export
		 */
		var PasswordSyncGroupsBetaApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.PasswordSyncGroupsBetaApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * This API creates a password sync group based on the specifications provided. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Create Password Sync Group
		         * @param {PasswordSyncGroupBeta} passwordSyncGroupBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createPasswordSyncGroup: function (passwordSyncGroupBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.createPasswordSyncGroup(passwordSyncGroupBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API deletes the specified password sync group. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Delete Password Sync Group by ID
		         * @param {string} id The ID of password sync group to delete.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deletePasswordSyncGroup: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.deletePasswordSyncGroup(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns the sync group for the specified ID. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Get Password Sync Group by ID
		         * @param {string} id The ID of password sync group to retrieve.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getPasswordSyncGroup: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getPasswordSyncGroup(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns a list of password sync groups. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Get Password Sync Group List
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getPasswordSyncGroups: function (limit, offset, count, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getPasswordSyncGroups(limit, offset, count, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API updates the specified password sync group. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Update Password Sync Group by ID
		         * @param {string} id The ID of password sync group to update.
		         * @param {PasswordSyncGroupBeta} passwordSyncGroupBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updatePasswordSyncGroup: function (id, passwordSyncGroupBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.updatePasswordSyncGroup(id, passwordSyncGroupBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.PasswordSyncGroupsBetaApiFp = PasswordSyncGroupsBetaApiFp;
		/**
		 * PasswordSyncGroupsBetaApi - factory interface
		 * @export
		 */
		var PasswordSyncGroupsBetaApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.PasswordSyncGroupsBetaApiFp)(configuration);
		    return {
		        /**
		         * This API creates a password sync group based on the specifications provided. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Create Password Sync Group
		         * @param {PasswordSyncGroupBeta} passwordSyncGroupBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createPasswordSyncGroup: function (passwordSyncGroupBeta, axiosOptions) {
		            return localVarFp.createPasswordSyncGroup(passwordSyncGroupBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API deletes the specified password sync group. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Delete Password Sync Group by ID
		         * @param {string} id The ID of password sync group to delete.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deletePasswordSyncGroup: function (id, axiosOptions) {
		            return localVarFp.deletePasswordSyncGroup(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API returns the sync group for the specified ID. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Get Password Sync Group by ID
		         * @param {string} id The ID of password sync group to retrieve.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getPasswordSyncGroup: function (id, axiosOptions) {
		            return localVarFp.getPasswordSyncGroup(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API returns a list of password sync groups. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Get Password Sync Group List
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getPasswordSyncGroups: function (limit, offset, count, axiosOptions) {
		            return localVarFp.getPasswordSyncGroups(limit, offset, count, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API updates the specified password sync group. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Update Password Sync Group by ID
		         * @param {string} id The ID of password sync group to update.
		         * @param {PasswordSyncGroupBeta} passwordSyncGroupBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updatePasswordSyncGroup: function (id, passwordSyncGroupBeta, axiosOptions) {
		            return localVarFp.updatePasswordSyncGroup(id, passwordSyncGroupBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.PasswordSyncGroupsBetaApiFactory = PasswordSyncGroupsBetaApiFactory;
		/**
		 * PasswordSyncGroupsBetaApi - object-oriented interface
		 * @export
		 * @class PasswordSyncGroupsBetaApi
		 * @extends {BaseAPI}
		 */
		var PasswordSyncGroupsBetaApi = /** @class */ (function (_super) {
		    __extends(PasswordSyncGroupsBetaApi, _super);
		    function PasswordSyncGroupsBetaApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * This API creates a password sync group based on the specifications provided. A token with ORG_ADMIN authority is required to call this API.
		     * @summary Create Password Sync Group
		     * @param {PasswordSyncGroupsBetaApiCreatePasswordSyncGroupRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof PasswordSyncGroupsBetaApi
		     */
		    PasswordSyncGroupsBetaApi.prototype.createPasswordSyncGroup = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.PasswordSyncGroupsBetaApiFp)(this.configuration).createPasswordSyncGroup(requestParameters.passwordSyncGroupBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API deletes the specified password sync group. A token with ORG_ADMIN authority is required to call this API.
		     * @summary Delete Password Sync Group by ID
		     * @param {PasswordSyncGroupsBetaApiDeletePasswordSyncGroupRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof PasswordSyncGroupsBetaApi
		     */
		    PasswordSyncGroupsBetaApi.prototype.deletePasswordSyncGroup = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.PasswordSyncGroupsBetaApiFp)(this.configuration).deletePasswordSyncGroup(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API returns the sync group for the specified ID. A token with ORG_ADMIN authority is required to call this API.
		     * @summary Get Password Sync Group by ID
		     * @param {PasswordSyncGroupsBetaApiGetPasswordSyncGroupRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof PasswordSyncGroupsBetaApi
		     */
		    PasswordSyncGroupsBetaApi.prototype.getPasswordSyncGroup = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.PasswordSyncGroupsBetaApiFp)(this.configuration).getPasswordSyncGroup(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API returns a list of password sync groups. A token with ORG_ADMIN authority is required to call this API.
		     * @summary Get Password Sync Group List
		     * @param {PasswordSyncGroupsBetaApiGetPasswordSyncGroupsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof PasswordSyncGroupsBetaApi
		     */
		    PasswordSyncGroupsBetaApi.prototype.getPasswordSyncGroups = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.PasswordSyncGroupsBetaApiFp)(this.configuration).getPasswordSyncGroups(requestParameters.limit, requestParameters.offset, requestParameters.count, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API updates the specified password sync group. A token with ORG_ADMIN authority is required to call this API.
		     * @summary Update Password Sync Group by ID
		     * @param {PasswordSyncGroupsBetaApiUpdatePasswordSyncGroupRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof PasswordSyncGroupsBetaApi
		     */
		    PasswordSyncGroupsBetaApi.prototype.updatePasswordSyncGroup = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.PasswordSyncGroupsBetaApiFp)(this.configuration).updatePasswordSyncGroup(requestParameters.id, requestParameters.passwordSyncGroupBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return PasswordSyncGroupsBetaApi;
		}(base_1.BaseAPI));
		exports.PasswordSyncGroupsBetaApi = PasswordSyncGroupsBetaApi;
		/**
		 * PersonalAccessTokensBetaApi - axios parameter creator
		 * @export
		 */
		var PersonalAccessTokensBetaApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * This creates a personal access token.
		         * @summary Create Personal Access Token
		         * @param {CreatePersonalAccessTokenRequestBeta} createPersonalAccessTokenRequestBeta Name and scope of personal access token.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createPersonalAccessToken: function (createPersonalAccessTokenRequestBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'createPersonalAccessTokenRequestBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('createPersonalAccessToken', 'createPersonalAccessTokenRequestBeta', createPersonalAccessTokenRequestBeta);
		                            localVarPath = "/personal-access-tokens";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(createPersonalAccessTokenRequestBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This deletes a personal access token.
		         * @summary Delete Personal Access Token
		         * @param {string} id The personal access token id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deletePersonalAccessToken: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('deletePersonalAccessToken', 'id', id);
		                            localVarPath = "/personal-access-tokens/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'DELETE' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets a collection of personal access tokens associated with the optional `owner-id`.  query parameter. If the `owner-id` query parameter is omitted, all personal access tokens  for a tenant will be retrieved, but the caller must have the \'idn:all-personal-access-tokens:read\' right.
		         * @summary List Personal Access Tokens
		         * @param {string} [ownerId] The identity ID of the owner whose personal access tokens should be listed.  If \&quot;me\&quot;, the caller should have the following right: \&#39;idn:my-personal-access-tokens:read\&#39; If an actual owner ID or if the &#x60;owner-id&#x60; parameter is omitted in the request,  the caller should have the following right: \&#39;idn:all-personal-access-tokens:read\&#39;.  If the caller has the following right, then managed personal access tokens associated with &#x60;owner-id&#x60; will be retrieved: \&#39;idn:managed-personal-access-tokens:read\&#39;
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **lastUsed**: *le, isnull*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listPersonalAccessTokens: function (ownerId, filters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/personal-access-tokens";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (ownerId !== undefined) {
		                                localVarQueryParameter['owner-id'] = ownerId;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This performs a targeted update to the field(s) of a Personal Access Token.
		         * @summary Patch Personal Access Token
		         * @param {string} id The Personal Access Token id
		         * @param {Array<JsonPatchOperationBeta>} jsonPatchOperationBeta A list of OAuth client update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.  The following fields are patchable: * name * scope
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchPersonalAccessToken: function (id, jsonPatchOperationBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('patchPersonalAccessToken', 'id', id);
		                            // verify required parameter 'jsonPatchOperationBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('patchPersonalAccessToken', 'jsonPatchOperationBeta', jsonPatchOperationBeta);
		                            localVarPath = "/personal-access-tokens/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PATCH' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json-patch+json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(jsonPatchOperationBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.PersonalAccessTokensBetaApiAxiosParamCreator = PersonalAccessTokensBetaApiAxiosParamCreator;
		/**
		 * PersonalAccessTokensBetaApi - functional programming interface
		 * @export
		 */
		var PersonalAccessTokensBetaApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.PersonalAccessTokensBetaApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * This creates a personal access token.
		         * @summary Create Personal Access Token
		         * @param {CreatePersonalAccessTokenRequestBeta} createPersonalAccessTokenRequestBeta Name and scope of personal access token.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createPersonalAccessToken: function (createPersonalAccessTokenRequestBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.createPersonalAccessToken(createPersonalAccessTokenRequestBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This deletes a personal access token.
		         * @summary Delete Personal Access Token
		         * @param {string} id The personal access token id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deletePersonalAccessToken: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.deletePersonalAccessToken(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets a collection of personal access tokens associated with the optional `owner-id`.  query parameter. If the `owner-id` query parameter is omitted, all personal access tokens  for a tenant will be retrieved, but the caller must have the \'idn:all-personal-access-tokens:read\' right.
		         * @summary List Personal Access Tokens
		         * @param {string} [ownerId] The identity ID of the owner whose personal access tokens should be listed.  If \&quot;me\&quot;, the caller should have the following right: \&#39;idn:my-personal-access-tokens:read\&#39; If an actual owner ID or if the &#x60;owner-id&#x60; parameter is omitted in the request,  the caller should have the following right: \&#39;idn:all-personal-access-tokens:read\&#39;.  If the caller has the following right, then managed personal access tokens associated with &#x60;owner-id&#x60; will be retrieved: \&#39;idn:managed-personal-access-tokens:read\&#39;
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **lastUsed**: *le, isnull*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listPersonalAccessTokens: function (ownerId, filters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listPersonalAccessTokens(ownerId, filters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This performs a targeted update to the field(s) of a Personal Access Token.
		         * @summary Patch Personal Access Token
		         * @param {string} id The Personal Access Token id
		         * @param {Array<JsonPatchOperationBeta>} jsonPatchOperationBeta A list of OAuth client update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.  The following fields are patchable: * name * scope
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchPersonalAccessToken: function (id, jsonPatchOperationBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.patchPersonalAccessToken(id, jsonPatchOperationBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.PersonalAccessTokensBetaApiFp = PersonalAccessTokensBetaApiFp;
		/**
		 * PersonalAccessTokensBetaApi - factory interface
		 * @export
		 */
		var PersonalAccessTokensBetaApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.PersonalAccessTokensBetaApiFp)(configuration);
		    return {
		        /**
		         * This creates a personal access token.
		         * @summary Create Personal Access Token
		         * @param {CreatePersonalAccessTokenRequestBeta} createPersonalAccessTokenRequestBeta Name and scope of personal access token.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createPersonalAccessToken: function (createPersonalAccessTokenRequestBeta, axiosOptions) {
		            return localVarFp.createPersonalAccessToken(createPersonalAccessTokenRequestBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This deletes a personal access token.
		         * @summary Delete Personal Access Token
		         * @param {string} id The personal access token id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deletePersonalAccessToken: function (id, axiosOptions) {
		            return localVarFp.deletePersonalAccessToken(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This gets a collection of personal access tokens associated with the optional `owner-id`.  query parameter. If the `owner-id` query parameter is omitted, all personal access tokens  for a tenant will be retrieved, but the caller must have the \'idn:all-personal-access-tokens:read\' right.
		         * @summary List Personal Access Tokens
		         * @param {string} [ownerId] The identity ID of the owner whose personal access tokens should be listed.  If \&quot;me\&quot;, the caller should have the following right: \&#39;idn:my-personal-access-tokens:read\&#39; If an actual owner ID or if the &#x60;owner-id&#x60; parameter is omitted in the request,  the caller should have the following right: \&#39;idn:all-personal-access-tokens:read\&#39;.  If the caller has the following right, then managed personal access tokens associated with &#x60;owner-id&#x60; will be retrieved: \&#39;idn:managed-personal-access-tokens:read\&#39;
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **lastUsed**: *le, isnull*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listPersonalAccessTokens: function (ownerId, filters, axiosOptions) {
		            return localVarFp.listPersonalAccessTokens(ownerId, filters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This performs a targeted update to the field(s) of a Personal Access Token.
		         * @summary Patch Personal Access Token
		         * @param {string} id The Personal Access Token id
		         * @param {Array<JsonPatchOperationBeta>} jsonPatchOperationBeta A list of OAuth client update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.  The following fields are patchable: * name * scope
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchPersonalAccessToken: function (id, jsonPatchOperationBeta, axiosOptions) {
		            return localVarFp.patchPersonalAccessToken(id, jsonPatchOperationBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.PersonalAccessTokensBetaApiFactory = PersonalAccessTokensBetaApiFactory;
		/**
		 * PersonalAccessTokensBetaApi - object-oriented interface
		 * @export
		 * @class PersonalAccessTokensBetaApi
		 * @extends {BaseAPI}
		 */
		var PersonalAccessTokensBetaApi = /** @class */ (function (_super) {
		    __extends(PersonalAccessTokensBetaApi, _super);
		    function PersonalAccessTokensBetaApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * This creates a personal access token.
		     * @summary Create Personal Access Token
		     * @param {PersonalAccessTokensBetaApiCreatePersonalAccessTokenRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof PersonalAccessTokensBetaApi
		     */
		    PersonalAccessTokensBetaApi.prototype.createPersonalAccessToken = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.PersonalAccessTokensBetaApiFp)(this.configuration).createPersonalAccessToken(requestParameters.createPersonalAccessTokenRequestBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This deletes a personal access token.
		     * @summary Delete Personal Access Token
		     * @param {PersonalAccessTokensBetaApiDeletePersonalAccessTokenRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof PersonalAccessTokensBetaApi
		     */
		    PersonalAccessTokensBetaApi.prototype.deletePersonalAccessToken = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.PersonalAccessTokensBetaApiFp)(this.configuration).deletePersonalAccessToken(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This gets a collection of personal access tokens associated with the optional `owner-id`.  query parameter. If the `owner-id` query parameter is omitted, all personal access tokens  for a tenant will be retrieved, but the caller must have the \'idn:all-personal-access-tokens:read\' right.
		     * @summary List Personal Access Tokens
		     * @param {PersonalAccessTokensBetaApiListPersonalAccessTokensRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof PersonalAccessTokensBetaApi
		     */
		    PersonalAccessTokensBetaApi.prototype.listPersonalAccessTokens = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.PersonalAccessTokensBetaApiFp)(this.configuration).listPersonalAccessTokens(requestParameters.ownerId, requestParameters.filters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This performs a targeted update to the field(s) of a Personal Access Token.
		     * @summary Patch Personal Access Token
		     * @param {PersonalAccessTokensBetaApiPatchPersonalAccessTokenRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof PersonalAccessTokensBetaApi
		     */
		    PersonalAccessTokensBetaApi.prototype.patchPersonalAccessToken = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.PersonalAccessTokensBetaApiFp)(this.configuration).patchPersonalAccessToken(requestParameters.id, requestParameters.jsonPatchOperationBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return PersonalAccessTokensBetaApi;
		}(base_1.BaseAPI));
		exports.PersonalAccessTokensBetaApi = PersonalAccessTokensBetaApi;
		/**
		 * PublicIdentitiesConfigBetaApi - axios parameter creator
		 * @export
		 */
		var PublicIdentitiesConfigBetaApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * This gets details of public identity config.
		         * @summary Get Public Identity Config
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getPublicIdentityConfig: function (axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/public-identities-config";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This updates the details of public identity config.
		         * @summary Update Public Identity Config
		         * @param {PublicIdentityConfigBeta} publicIdentityConfigBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updatePublicIdentityConfig: function (publicIdentityConfigBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'publicIdentityConfigBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('updatePublicIdentityConfig', 'publicIdentityConfigBeta', publicIdentityConfigBeta);
		                            localVarPath = "/public-identities-config";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PUT' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(publicIdentityConfigBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.PublicIdentitiesConfigBetaApiAxiosParamCreator = PublicIdentitiesConfigBetaApiAxiosParamCreator;
		/**
		 * PublicIdentitiesConfigBetaApi - functional programming interface
		 * @export
		 */
		var PublicIdentitiesConfigBetaApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.PublicIdentitiesConfigBetaApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * This gets details of public identity config.
		         * @summary Get Public Identity Config
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getPublicIdentityConfig: function (axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getPublicIdentityConfig(axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This updates the details of public identity config.
		         * @summary Update Public Identity Config
		         * @param {PublicIdentityConfigBeta} publicIdentityConfigBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updatePublicIdentityConfig: function (publicIdentityConfigBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.updatePublicIdentityConfig(publicIdentityConfigBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.PublicIdentitiesConfigBetaApiFp = PublicIdentitiesConfigBetaApiFp;
		/**
		 * PublicIdentitiesConfigBetaApi - factory interface
		 * @export
		 */
		var PublicIdentitiesConfigBetaApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.PublicIdentitiesConfigBetaApiFp)(configuration);
		    return {
		        /**
		         * This gets details of public identity config.
		         * @summary Get Public Identity Config
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getPublicIdentityConfig: function (axiosOptions) {
		            return localVarFp.getPublicIdentityConfig(axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This updates the details of public identity config.
		         * @summary Update Public Identity Config
		         * @param {PublicIdentityConfigBeta} publicIdentityConfigBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updatePublicIdentityConfig: function (publicIdentityConfigBeta, axiosOptions) {
		            return localVarFp.updatePublicIdentityConfig(publicIdentityConfigBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.PublicIdentitiesConfigBetaApiFactory = PublicIdentitiesConfigBetaApiFactory;
		/**
		 * PublicIdentitiesConfigBetaApi - object-oriented interface
		 * @export
		 * @class PublicIdentitiesConfigBetaApi
		 * @extends {BaseAPI}
		 */
		var PublicIdentitiesConfigBetaApi = /** @class */ (function (_super) {
		    __extends(PublicIdentitiesConfigBetaApi, _super);
		    function PublicIdentitiesConfigBetaApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * This gets details of public identity config.
		     * @summary Get Public Identity Config
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof PublicIdentitiesConfigBetaApi
		     */
		    PublicIdentitiesConfigBetaApi.prototype.getPublicIdentityConfig = function (axiosOptions) {
		        var _this = this;
		        return (0, exports.PublicIdentitiesConfigBetaApiFp)(this.configuration).getPublicIdentityConfig(axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This updates the details of public identity config.
		     * @summary Update Public Identity Config
		     * @param {PublicIdentitiesConfigBetaApiUpdatePublicIdentityConfigRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof PublicIdentitiesConfigBetaApi
		     */
		    PublicIdentitiesConfigBetaApi.prototype.updatePublicIdentityConfig = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.PublicIdentitiesConfigBetaApiFp)(this.configuration).updatePublicIdentityConfig(requestParameters.publicIdentityConfigBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return PublicIdentitiesConfigBetaApi;
		}(base_1.BaseAPI));
		exports.PublicIdentitiesConfigBetaApi = PublicIdentitiesConfigBetaApi;
		/**
		 * RequestableObjectsBetaApi - axios parameter creator
		 * @export
		 */
		var RequestableObjectsBetaApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * This endpoint returns a list of acccess items that that can be requested through the Access Request endpoints. Access items are marked with AVAILABLE, PENDING or ASSIGNED with respect to the identity provided using *identity-id* query param. Any authenticated token can call this endpoint to see their requestable access items. A token with ORG_ADMIN authority is required to call this endpoint to return a list of all of the requestable access items for the org or for another identity.
		         * @summary Requestable Objects List
		         * @param {string} [identityId] If present, the value returns only requestable objects for the specified identity.  * Admin users can call this with any identity ID value.  * Non-admin users can only specify *me* or pass their own identity ID value.  * If absent, returns a list of all requestable objects for the tenant. Only admin users can make such a call. In this case, the available, pending, assigned accesses will not be annotated in the result.
		         * @param {Array<RequestableObjectTypeBeta>} [types] Filters the results to the specified type/types, where each type is one of ROLE or ACCESS_PROFILE. If absent, all types are returned. Support for additional types may be added in the future without notice.
		         * @param {string} [term] It allows searching requestable access items with a partial match on the name or description. If term is provided, then the *filter* query parameter will be ignored.
		         * @param {Array<RequestableObjectRequestStatusBeta>} [statuses] Filters the result to the specified status/statuses, where each status is one of AVAILABLE, ASSIGNED, or PENDING. It is an error to specify this parameter without also specifying an *identity-id* parameter. Additional statuses may be added in the future without notice.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **name**: *eq, in, sw*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listRequestableObjects: function (identityId, types, term, statuses, limit, offset, count, filters, sorters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/requestable-objects";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (identityId !== undefined) {
		                                localVarQueryParameter['identity-id'] = identityId;
		                            }
		                            if (types) {
		                                localVarQueryParameter['types'] = types.join(base_1.COLLECTION_FORMATS.csv);
		                            }
		                            if (term !== undefined) {
		                                localVarQueryParameter['term'] = term;
		                            }
		                            if (statuses) {
		                                localVarQueryParameter['statuses'] = statuses.join(base_1.COLLECTION_FORMATS.csv);
		                            }
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.RequestableObjectsBetaApiAxiosParamCreator = RequestableObjectsBetaApiAxiosParamCreator;
		/**
		 * RequestableObjectsBetaApi - functional programming interface
		 * @export
		 */
		var RequestableObjectsBetaApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.RequestableObjectsBetaApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * This endpoint returns a list of acccess items that that can be requested through the Access Request endpoints. Access items are marked with AVAILABLE, PENDING or ASSIGNED with respect to the identity provided using *identity-id* query param. Any authenticated token can call this endpoint to see their requestable access items. A token with ORG_ADMIN authority is required to call this endpoint to return a list of all of the requestable access items for the org or for another identity.
		         * @summary Requestable Objects List
		         * @param {string} [identityId] If present, the value returns only requestable objects for the specified identity.  * Admin users can call this with any identity ID value.  * Non-admin users can only specify *me* or pass their own identity ID value.  * If absent, returns a list of all requestable objects for the tenant. Only admin users can make such a call. In this case, the available, pending, assigned accesses will not be annotated in the result.
		         * @param {Array<RequestableObjectTypeBeta>} [types] Filters the results to the specified type/types, where each type is one of ROLE or ACCESS_PROFILE. If absent, all types are returned. Support for additional types may be added in the future without notice.
		         * @param {string} [term] It allows searching requestable access items with a partial match on the name or description. If term is provided, then the *filter* query parameter will be ignored.
		         * @param {Array<RequestableObjectRequestStatusBeta>} [statuses] Filters the result to the specified status/statuses, where each status is one of AVAILABLE, ASSIGNED, or PENDING. It is an error to specify this parameter without also specifying an *identity-id* parameter. Additional statuses may be added in the future without notice.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **name**: *eq, in, sw*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listRequestableObjects: function (identityId, types, term, statuses, limit, offset, count, filters, sorters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listRequestableObjects(identityId, types, term, statuses, limit, offset, count, filters, sorters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.RequestableObjectsBetaApiFp = RequestableObjectsBetaApiFp;
		/**
		 * RequestableObjectsBetaApi - factory interface
		 * @export
		 */
		var RequestableObjectsBetaApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.RequestableObjectsBetaApiFp)(configuration);
		    return {
		        /**
		         * This endpoint returns a list of acccess items that that can be requested through the Access Request endpoints. Access items are marked with AVAILABLE, PENDING or ASSIGNED with respect to the identity provided using *identity-id* query param. Any authenticated token can call this endpoint to see their requestable access items. A token with ORG_ADMIN authority is required to call this endpoint to return a list of all of the requestable access items for the org or for another identity.
		         * @summary Requestable Objects List
		         * @param {string} [identityId] If present, the value returns only requestable objects for the specified identity.  * Admin users can call this with any identity ID value.  * Non-admin users can only specify *me* or pass their own identity ID value.  * If absent, returns a list of all requestable objects for the tenant. Only admin users can make such a call. In this case, the available, pending, assigned accesses will not be annotated in the result.
		         * @param {Array<RequestableObjectTypeBeta>} [types] Filters the results to the specified type/types, where each type is one of ROLE or ACCESS_PROFILE. If absent, all types are returned. Support for additional types may be added in the future without notice.
		         * @param {string} [term] It allows searching requestable access items with a partial match on the name or description. If term is provided, then the *filter* query parameter will be ignored.
		         * @param {Array<RequestableObjectRequestStatusBeta>} [statuses] Filters the result to the specified status/statuses, where each status is one of AVAILABLE, ASSIGNED, or PENDING. It is an error to specify this parameter without also specifying an *identity-id* parameter. Additional statuses may be added in the future without notice.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **name**: *eq, in, sw*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listRequestableObjects: function (identityId, types, term, statuses, limit, offset, count, filters, sorters, axiosOptions) {
		            return localVarFp.listRequestableObjects(identityId, types, term, statuses, limit, offset, count, filters, sorters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.RequestableObjectsBetaApiFactory = RequestableObjectsBetaApiFactory;
		/**
		 * RequestableObjectsBetaApi - object-oriented interface
		 * @export
		 * @class RequestableObjectsBetaApi
		 * @extends {BaseAPI}
		 */
		var RequestableObjectsBetaApi = /** @class */ (function (_super) {
		    __extends(RequestableObjectsBetaApi, _super);
		    function RequestableObjectsBetaApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * This endpoint returns a list of acccess items that that can be requested through the Access Request endpoints. Access items are marked with AVAILABLE, PENDING or ASSIGNED with respect to the identity provided using *identity-id* query param. Any authenticated token can call this endpoint to see their requestable access items. A token with ORG_ADMIN authority is required to call this endpoint to return a list of all of the requestable access items for the org or for another identity.
		     * @summary Requestable Objects List
		     * @param {RequestableObjectsBetaApiListRequestableObjectsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof RequestableObjectsBetaApi
		     */
		    RequestableObjectsBetaApi.prototype.listRequestableObjects = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.RequestableObjectsBetaApiFp)(this.configuration).listRequestableObjects(requestParameters.identityId, requestParameters.types, requestParameters.term, requestParameters.statuses, requestParameters.limit, requestParameters.offset, requestParameters.count, requestParameters.filters, requestParameters.sorters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return RequestableObjectsBetaApi;
		}(base_1.BaseAPI));
		exports.RequestableObjectsBetaApi = RequestableObjectsBetaApi;
		/**
		 * RoleInsightsBetaApi - axios parameter creator
		 * @export
		 */
		var RoleInsightsBetaApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * Submits a create role insights request to the role insights application. At this time there are no parameters. All business roles will be processed for the customer.
		         * @summary Generate insights for roles
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        createRoleInsightRequests: function (axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/role-insights/requests";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This endpoint returns the entitlement insights for a role.
		         * @summary Download entitlement insights for a role
		         * @param {string} insightId The role insight id
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **identitiesWithAccess**  The default sort is **identitiesWithAccess** in descending order.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **name**: *sw*  **description**: *sw*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        downloadRoleInsightsEntitlementsChanges: function (insightId, sorters, filters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'insightId' is not null or undefined
		                            (0, common_1.assertParamExists)('downloadRoleInsightsEntitlementsChanges', 'insightId', insightId);
		                            localVarPath = "/role-insights/{insightId}/entitlement-changes/download"
		                                .replace("{".concat("insightId", "}"), encodeURIComponent(String(insightId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Role insights suggests entitlements to be added for a role. This endpoint returns a list of identities in the role, with or without the entitlements, for a suggested entitlement so that the user can see which identities would be affected if the suggested entitlement were to be added to the role.
		         * @summary Get identities for a suggested entitlement (for a role)
		         * @param {string} insightId The role insight id
		         * @param {string} entitlementId The entitlement id
		         * @param {boolean} [hasEntitlement] Identity has this entitlement or not
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name**
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **name**: *sw*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getEntitlementChangesIdentities: function (insightId, entitlementId, hasEntitlement, offset, limit, count, sorters, filters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'insightId' is not null or undefined
		                            (0, common_1.assertParamExists)('getEntitlementChangesIdentities', 'insightId', insightId);
		                            // verify required parameter 'entitlementId' is not null or undefined
		                            (0, common_1.assertParamExists)('getEntitlementChangesIdentities', 'entitlementId', entitlementId);
		                            localVarPath = "/role-insights/{insightId}/entitlement-changes/{entitlementId}/identities"
		                                .replace("{".concat("insightId", "}"), encodeURIComponent(String(insightId)))
		                                .replace("{".concat("entitlementId", "}"), encodeURIComponent(String(entitlementId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (hasEntitlement !== undefined) {
		                                localVarQueryParameter['hasEntitlement'] = hasEntitlement;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This endpoint gets role insights information for a role.
		         * @summary Get a single role insight
		         * @param {string} insightId The role insight id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getRoleInsight: function (insightId, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'insightId' is not null or undefined
		                            (0, common_1.assertParamExists)('getRoleInsight', 'insightId', insightId);
		                            localVarPath = "/role-insights/{insightId}"
		                                .replace("{".concat("insightId", "}"), encodeURIComponent(String(insightId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This method returns detailed role insights for each role.
		         * @summary Get role insights
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **numberOfUpdates, identitiesWithAccess, totalNumberOfIdentities**
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **name**: *sw*  **ownerName**: *sw*  **description**: *sw*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getRoleInsights: function (offset, limit, count, sorters, filters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/role-insights";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This endpoint gets the entitlements for a role. The term \"current\" is to distinguish from the entitlement(s) an insight might recommend adding.
		         * @summary Get current entitlement for a role
		         * @param {string} insightId The role insight id
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **name**: *sw*  **description**: *sw*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getRoleInsightsCurrentEntitlements: function (insightId, filters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'insightId' is not null or undefined
		                            (0, common_1.assertParamExists)('getRoleInsightsCurrentEntitlements', 'insightId', insightId);
		                            localVarPath = "/role-insights/{insightId}/current-entitlements"
		                                .replace("{".concat("insightId", "}"), encodeURIComponent(String(insightId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This endpoint returns entitlement insights for a role.
		         * @summary Get entitlement insights for a role
		         * @param {string} insightId The role insight id
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **identitiesWithAccess, name**
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **name**: *sw*  **description**: *sw*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getRoleInsightsEntitlementsChanges: function (insightId, sorters, filters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'insightId' is not null or undefined
		                            (0, common_1.assertParamExists)('getRoleInsightsEntitlementsChanges', 'insightId', insightId);
		                            localVarPath = "/role-insights/{insightId}/entitlement-changes"
		                                .replace("{".concat("insightId", "}"), encodeURIComponent(String(insightId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This endpoint returns details of a prior role insights request.
		         * @summary Returns metadata from prior request.
		         * @param {string} id The role insights request id
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        getRoleInsightsRequests: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getRoleInsightsRequests', 'id', id);
		                            localVarPath = "/role-insights/requests/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This method returns high level summary information for role insights for a customer.
		         * @summary Get role insights summary information
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getRoleInsightsSummary: function (axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/role-insights/summary";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.RoleInsightsBetaApiAxiosParamCreator = RoleInsightsBetaApiAxiosParamCreator;
		/**
		 * RoleInsightsBetaApi - functional programming interface
		 * @export
		 */
		var RoleInsightsBetaApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.RoleInsightsBetaApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * Submits a create role insights request to the role insights application. At this time there are no parameters. All business roles will be processed for the customer.
		         * @summary Generate insights for roles
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        createRoleInsightRequests: function (axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.createRoleInsightRequests(axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This endpoint returns the entitlement insights for a role.
		         * @summary Download entitlement insights for a role
		         * @param {string} insightId The role insight id
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **identitiesWithAccess**  The default sort is **identitiesWithAccess** in descending order.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **name**: *sw*  **description**: *sw*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        downloadRoleInsightsEntitlementsChanges: function (insightId, sorters, filters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.downloadRoleInsightsEntitlementsChanges(insightId, sorters, filters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Role insights suggests entitlements to be added for a role. This endpoint returns a list of identities in the role, with or without the entitlements, for a suggested entitlement so that the user can see which identities would be affected if the suggested entitlement were to be added to the role.
		         * @summary Get identities for a suggested entitlement (for a role)
		         * @param {string} insightId The role insight id
		         * @param {string} entitlementId The entitlement id
		         * @param {boolean} [hasEntitlement] Identity has this entitlement or not
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name**
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **name**: *sw*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getEntitlementChangesIdentities: function (insightId, entitlementId, hasEntitlement, offset, limit, count, sorters, filters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getEntitlementChangesIdentities(insightId, entitlementId, hasEntitlement, offset, limit, count, sorters, filters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This endpoint gets role insights information for a role.
		         * @summary Get a single role insight
		         * @param {string} insightId The role insight id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getRoleInsight: function (insightId, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getRoleInsight(insightId, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This method returns detailed role insights for each role.
		         * @summary Get role insights
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **numberOfUpdates, identitiesWithAccess, totalNumberOfIdentities**
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **name**: *sw*  **ownerName**: *sw*  **description**: *sw*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getRoleInsights: function (offset, limit, count, sorters, filters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getRoleInsights(offset, limit, count, sorters, filters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This endpoint gets the entitlements for a role. The term \"current\" is to distinguish from the entitlement(s) an insight might recommend adding.
		         * @summary Get current entitlement for a role
		         * @param {string} insightId The role insight id
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **name**: *sw*  **description**: *sw*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getRoleInsightsCurrentEntitlements: function (insightId, filters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getRoleInsightsCurrentEntitlements(insightId, filters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This endpoint returns entitlement insights for a role.
		         * @summary Get entitlement insights for a role
		         * @param {string} insightId The role insight id
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **identitiesWithAccess, name**
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **name**: *sw*  **description**: *sw*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getRoleInsightsEntitlementsChanges: function (insightId, sorters, filters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getRoleInsightsEntitlementsChanges(insightId, sorters, filters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This endpoint returns details of a prior role insights request.
		         * @summary Returns metadata from prior request.
		         * @param {string} id The role insights request id
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        getRoleInsightsRequests: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getRoleInsightsRequests(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This method returns high level summary information for role insights for a customer.
		         * @summary Get role insights summary information
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getRoleInsightsSummary: function (axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getRoleInsightsSummary(axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.RoleInsightsBetaApiFp = RoleInsightsBetaApiFp;
		/**
		 * RoleInsightsBetaApi - factory interface
		 * @export
		 */
		var RoleInsightsBetaApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.RoleInsightsBetaApiFp)(configuration);
		    return {
		        /**
		         * Submits a create role insights request to the role insights application. At this time there are no parameters. All business roles will be processed for the customer.
		         * @summary Generate insights for roles
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        createRoleInsightRequests: function (axiosOptions) {
		            return localVarFp.createRoleInsightRequests(axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This endpoint returns the entitlement insights for a role.
		         * @summary Download entitlement insights for a role
		         * @param {string} insightId The role insight id
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **identitiesWithAccess**  The default sort is **identitiesWithAccess** in descending order.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **name**: *sw*  **description**: *sw*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        downloadRoleInsightsEntitlementsChanges: function (insightId, sorters, filters, axiosOptions) {
		            return localVarFp.downloadRoleInsightsEntitlementsChanges(insightId, sorters, filters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Role insights suggests entitlements to be added for a role. This endpoint returns a list of identities in the role, with or without the entitlements, for a suggested entitlement so that the user can see which identities would be affected if the suggested entitlement were to be added to the role.
		         * @summary Get identities for a suggested entitlement (for a role)
		         * @param {string} insightId The role insight id
		         * @param {string} entitlementId The entitlement id
		         * @param {boolean} [hasEntitlement] Identity has this entitlement or not
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name**
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **name**: *sw*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getEntitlementChangesIdentities: function (insightId, entitlementId, hasEntitlement, offset, limit, count, sorters, filters, axiosOptions) {
		            return localVarFp.getEntitlementChangesIdentities(insightId, entitlementId, hasEntitlement, offset, limit, count, sorters, filters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This endpoint gets role insights information for a role.
		         * @summary Get a single role insight
		         * @param {string} insightId The role insight id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getRoleInsight: function (insightId, axiosOptions) {
		            return localVarFp.getRoleInsight(insightId, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This method returns detailed role insights for each role.
		         * @summary Get role insights
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **numberOfUpdates, identitiesWithAccess, totalNumberOfIdentities**
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **name**: *sw*  **ownerName**: *sw*  **description**: *sw*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getRoleInsights: function (offset, limit, count, sorters, filters, axiosOptions) {
		            return localVarFp.getRoleInsights(offset, limit, count, sorters, filters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This endpoint gets the entitlements for a role. The term \"current\" is to distinguish from the entitlement(s) an insight might recommend adding.
		         * @summary Get current entitlement for a role
		         * @param {string} insightId The role insight id
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **name**: *sw*  **description**: *sw*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getRoleInsightsCurrentEntitlements: function (insightId, filters, axiosOptions) {
		            return localVarFp.getRoleInsightsCurrentEntitlements(insightId, filters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This endpoint returns entitlement insights for a role.
		         * @summary Get entitlement insights for a role
		         * @param {string} insightId The role insight id
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **identitiesWithAccess, name**
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **name**: *sw*  **description**: *sw*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getRoleInsightsEntitlementsChanges: function (insightId, sorters, filters, axiosOptions) {
		            return localVarFp.getRoleInsightsEntitlementsChanges(insightId, sorters, filters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This endpoint returns details of a prior role insights request.
		         * @summary Returns metadata from prior request.
		         * @param {string} id The role insights request id
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        getRoleInsightsRequests: function (id, axiosOptions) {
		            return localVarFp.getRoleInsightsRequests(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This method returns high level summary information for role insights for a customer.
		         * @summary Get role insights summary information
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getRoleInsightsSummary: function (axiosOptions) {
		            return localVarFp.getRoleInsightsSummary(axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.RoleInsightsBetaApiFactory = RoleInsightsBetaApiFactory;
		/**
		 * RoleInsightsBetaApi - object-oriented interface
		 * @export
		 * @class RoleInsightsBetaApi
		 * @extends {BaseAPI}
		 */
		var RoleInsightsBetaApi = /** @class */ (function (_super) {
		    __extends(RoleInsightsBetaApi, _super);
		    function RoleInsightsBetaApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * Submits a create role insights request to the role insights application. At this time there are no parameters. All business roles will be processed for the customer.
		     * @summary Generate insights for roles
		     * @param {*} [axiosOptions] Override http request option.
		     * @deprecated
		     * @throws {RequiredError}
		     * @memberof RoleInsightsBetaApi
		     */
		    RoleInsightsBetaApi.prototype.createRoleInsightRequests = function (axiosOptions) {
		        var _this = this;
		        return (0, exports.RoleInsightsBetaApiFp)(this.configuration).createRoleInsightRequests(axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This endpoint returns the entitlement insights for a role.
		     * @summary Download entitlement insights for a role
		     * @param {RoleInsightsBetaApiDownloadRoleInsightsEntitlementsChangesRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof RoleInsightsBetaApi
		     */
		    RoleInsightsBetaApi.prototype.downloadRoleInsightsEntitlementsChanges = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.RoleInsightsBetaApiFp)(this.configuration).downloadRoleInsightsEntitlementsChanges(requestParameters.insightId, requestParameters.sorters, requestParameters.filters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Role insights suggests entitlements to be added for a role. This endpoint returns a list of identities in the role, with or without the entitlements, for a suggested entitlement so that the user can see which identities would be affected if the suggested entitlement were to be added to the role.
		     * @summary Get identities for a suggested entitlement (for a role)
		     * @param {RoleInsightsBetaApiGetEntitlementChangesIdentitiesRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof RoleInsightsBetaApi
		     */
		    RoleInsightsBetaApi.prototype.getEntitlementChangesIdentities = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.RoleInsightsBetaApiFp)(this.configuration).getEntitlementChangesIdentities(requestParameters.insightId, requestParameters.entitlementId, requestParameters.hasEntitlement, requestParameters.offset, requestParameters.limit, requestParameters.count, requestParameters.sorters, requestParameters.filters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This endpoint gets role insights information for a role.
		     * @summary Get a single role insight
		     * @param {RoleInsightsBetaApiGetRoleInsightRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof RoleInsightsBetaApi
		     */
		    RoleInsightsBetaApi.prototype.getRoleInsight = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.RoleInsightsBetaApiFp)(this.configuration).getRoleInsight(requestParameters.insightId, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This method returns detailed role insights for each role.
		     * @summary Get role insights
		     * @param {RoleInsightsBetaApiGetRoleInsightsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof RoleInsightsBetaApi
		     */
		    RoleInsightsBetaApi.prototype.getRoleInsights = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.RoleInsightsBetaApiFp)(this.configuration).getRoleInsights(requestParameters.offset, requestParameters.limit, requestParameters.count, requestParameters.sorters, requestParameters.filters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This endpoint gets the entitlements for a role. The term \"current\" is to distinguish from the entitlement(s) an insight might recommend adding.
		     * @summary Get current entitlement for a role
		     * @param {RoleInsightsBetaApiGetRoleInsightsCurrentEntitlementsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof RoleInsightsBetaApi
		     */
		    RoleInsightsBetaApi.prototype.getRoleInsightsCurrentEntitlements = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.RoleInsightsBetaApiFp)(this.configuration).getRoleInsightsCurrentEntitlements(requestParameters.insightId, requestParameters.filters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This endpoint returns entitlement insights for a role.
		     * @summary Get entitlement insights for a role
		     * @param {RoleInsightsBetaApiGetRoleInsightsEntitlementsChangesRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof RoleInsightsBetaApi
		     */
		    RoleInsightsBetaApi.prototype.getRoleInsightsEntitlementsChanges = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.RoleInsightsBetaApiFp)(this.configuration).getRoleInsightsEntitlementsChanges(requestParameters.insightId, requestParameters.sorters, requestParameters.filters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This endpoint returns details of a prior role insights request.
		     * @summary Returns metadata from prior request.
		     * @param {RoleInsightsBetaApiGetRoleInsightsRequestsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @deprecated
		     * @throws {RequiredError}
		     * @memberof RoleInsightsBetaApi
		     */
		    RoleInsightsBetaApi.prototype.getRoleInsightsRequests = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.RoleInsightsBetaApiFp)(this.configuration).getRoleInsightsRequests(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This method returns high level summary information for role insights for a customer.
		     * @summary Get role insights summary information
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof RoleInsightsBetaApi
		     */
		    RoleInsightsBetaApi.prototype.getRoleInsightsSummary = function (axiosOptions) {
		        var _this = this;
		        return (0, exports.RoleInsightsBetaApiFp)(this.configuration).getRoleInsightsSummary(axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return RoleInsightsBetaApi;
		}(base_1.BaseAPI));
		exports.RoleInsightsBetaApi = RoleInsightsBetaApi;
		/**
		 * RolesBetaApi - axios parameter creator
		 * @export
		 */
		var RolesBetaApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * This API initiates a bulk deletion of one or more Roles.  A token with API, ORG_ADMIN, ROLE_ADMIN, or ROLE_SUBADMIN authority is required to call this API. In addition, a token with ROLE_SUBADMIN authority may only call this API if all Roles included in the request are associated to Sources with management workgroups of which the ROLE_SUBADMIN is a member.
		         * @summary Delete Role(s)
		         * @param {RoleBulkDeleteRequestBeta} roleBulkDeleteRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        bulkDeleteRoles: function (roleBulkDeleteRequestBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'roleBulkDeleteRequestBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('bulkDeleteRoles', 'roleBulkDeleteRequestBeta', roleBulkDeleteRequestBeta);
		                            localVarPath = "/roles/bulk-delete";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(roleBulkDeleteRequestBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API creates a role. You must have a token with API, ORG_ADMIN, ROLE_ADMIN, or ROLE_SUBADMIN authority to call this API.  In addition, a ROLE_SUBADMIN may not create a role including an access profile if that access profile is associated with a source the ROLE_SUBADMIN is not associated with themselves.  The maximum supported length for the description field is 2000 characters. Longer descriptions will be preserved for existing roles. However, any new roles as well as any updates to existing descriptions will be limited to 2000 characters.
		         * @summary Create a Role
		         * @param {RoleBeta} roleBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createRole: function (roleBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'roleBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('createRole', 'roleBeta', roleBeta);
		                            localVarPath = "/roles";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(roleBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API deletes a Role by its ID. A token with API, ORG_ADMIN, ROLE_ADMIN, or ROLE_SUBADMIN authority is required to call this API. In addition, a token with ROLE_SUBADMIN authority may only call this API if all Access Profiles included in the Role are associated to Sources with management workgroups of which the ROLE_SUBADMIN is a member.
		         * @summary Delete a Role
		         * @param {string} id ID of the Role
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteRole: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('deleteRole', 'id', id);
		                            localVarPath = "/roles/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'DELETE' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns a Role by its ID.  A token with API, ORG_ADMIN, ROLE_ADMIN, or ROLE_SUBADMIN authority is required to call this API. In addition, a token with ROLE_SUBADMIN authority may only call this API if all Access Profiles included in the Role are associated to Sources with management workgroups of which the ROLE_SUBADMIN is a member.
		         * @summary Get a Role
		         * @param {string} id ID of the Role
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getRole: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getRole', 'id', id);
		                            localVarPath = "/roles/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         *
		         * @summary Identities assigned a Role
		         * @param {string} id ID of the Role for which the assigned Identities are to be listed
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **aliasName**: *eq, sw*  **email**: *eq, sw*  **name**: *eq, sw, co*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **id, name, aliasName, email**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getRoleAssignedIdentities: function (id, limit, offset, count, filters, sorters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getRoleAssignedIdentities', 'id', id);
		                            localVarPath = "/roles/{id}/assigned-identities"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API lists the Entitlements associated with a given role.  A token with API, ORG_ADMIN, ROLE_ADMIN, or ROLE_SUBADMIN authority is required to call this API.
		         * @summary List role\'s Entitlements
		         * @param {string} id ID of the containing role
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **name**: *eq, sw*  **attribute**: *eq, sw*  **value**: *eq, sw*  **created**: *gt, lt, ge, le*  **modified**: *gt, lt, ge, le*  **owner.id**: *eq, in*  **source.id**: *eq, in*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name, attribute, value, created, modified**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getRoleEntitlements: function (id, limit, offset, count, filters, sorters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getRoleEntitlements', 'id', id);
		                            localVarPath = "/roles/{id}/entitlements"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns a list of Roles.  A token with API, ORG_ADMIN, ROLE_ADMIN, or ROLE_SUBADMIN authority is required to call this API.
		         * @summary List Roles
		         * @param {string} [forSubadmin] If provided, filters the returned list according to what is visible to the indicated ROLE_SUBADMIN Identity. The value of the parameter is either an Identity ID, or the special value **me**, which is shorthand for the calling Identity\&#39;s ID. A 400 Bad Request error is returned if the **for-subadmin** parameter is specified for an Identity that is not a subadmin.
		         * @param {number} [limit] Note that for this API the maximum value for limit is 50. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **name**: *eq, sw*  **created**: *gt, lt, ge, le*  **modified**: *gt, lt, ge, le*  **owner.id**: *eq, in*  **requestable**: *eq*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name, created, modified**
		         * @param {string} [forSegmentIds] If present and not empty, additionally filters Roles to those which are assigned to the Segment(s) with the specified IDs.  If segmentation is currently unavailable, specifying this parameter results in an error.
		         * @param {boolean} [includeUnsegmented] Whether or not the response list should contain unsegmented Roles. If *for-segment-ids* is absent or empty, specifying *include-unsegmented* as false results in an error.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listRoles: function (forSubadmin, limit, offset, count, filters, sorters, forSegmentIds, includeUnsegmented, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/roles";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (forSubadmin !== undefined) {
		                                localVarQueryParameter['for-subadmin'] = forSubadmin;
		                            }
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            if (forSegmentIds !== undefined) {
		                                localVarQueryParameter['for-segment-ids'] = forSegmentIds;
		                            }
		                            if (includeUnsegmented !== undefined) {
		                                localVarQueryParameter['include-unsegmented'] = includeUnsegmented;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API updates an existing Role using [JSON Patch](https://tools.ietf.org/html/rfc6902) syntax.  The following fields are patchable: **name**, **description**, **enabled**, **owner**, **accessProfiles**, **membership**, **requestable**, **accessRequestConfig**, **revokeRequestConfig**, **segments** A token with API, ORG_ADMIN, ROLE_ADMIN, or ROLE_SUBADMIN authority is required to call this API. In addition, a token with ROLE_SUBADMIN authority may only call this API if all Access Profiles included in the Role are associated to Sources with management workgroups of which the ROLE_SUBADMIN is a member. The maximum supported length for the description field is 2000 characters. Longer descriptions will be preserved for existing roles, however, any new roles as well as any updates to existing descriptions will be limited to 2000 characters.
		         * @summary Patch a specified Role
		         * @param {string} id ID of the Role to patch
		         * @param {Array<JsonPatchOperationBeta>} jsonPatchOperationBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchRole: function (id, jsonPatchOperationBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('patchRole', 'id', id);
		                            // verify required parameter 'jsonPatchOperationBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('patchRole', 'jsonPatchOperationBeta', jsonPatchOperationBeta);
		                            localVarPath = "/roles/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PATCH' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json-patch+json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(jsonPatchOperationBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.RolesBetaApiAxiosParamCreator = RolesBetaApiAxiosParamCreator;
		/**
		 * RolesBetaApi - functional programming interface
		 * @export
		 */
		var RolesBetaApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.RolesBetaApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * This API initiates a bulk deletion of one or more Roles.  A token with API, ORG_ADMIN, ROLE_ADMIN, or ROLE_SUBADMIN authority is required to call this API. In addition, a token with ROLE_SUBADMIN authority may only call this API if all Roles included in the request are associated to Sources with management workgroups of which the ROLE_SUBADMIN is a member.
		         * @summary Delete Role(s)
		         * @param {RoleBulkDeleteRequestBeta} roleBulkDeleteRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        bulkDeleteRoles: function (roleBulkDeleteRequestBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.bulkDeleteRoles(roleBulkDeleteRequestBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API creates a role. You must have a token with API, ORG_ADMIN, ROLE_ADMIN, or ROLE_SUBADMIN authority to call this API.  In addition, a ROLE_SUBADMIN may not create a role including an access profile if that access profile is associated with a source the ROLE_SUBADMIN is not associated with themselves.  The maximum supported length for the description field is 2000 characters. Longer descriptions will be preserved for existing roles. However, any new roles as well as any updates to existing descriptions will be limited to 2000 characters.
		         * @summary Create a Role
		         * @param {RoleBeta} roleBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createRole: function (roleBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.createRole(roleBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API deletes a Role by its ID. A token with API, ORG_ADMIN, ROLE_ADMIN, or ROLE_SUBADMIN authority is required to call this API. In addition, a token with ROLE_SUBADMIN authority may only call this API if all Access Profiles included in the Role are associated to Sources with management workgroups of which the ROLE_SUBADMIN is a member.
		         * @summary Delete a Role
		         * @param {string} id ID of the Role
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteRole: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.deleteRole(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns a Role by its ID.  A token with API, ORG_ADMIN, ROLE_ADMIN, or ROLE_SUBADMIN authority is required to call this API. In addition, a token with ROLE_SUBADMIN authority may only call this API if all Access Profiles included in the Role are associated to Sources with management workgroups of which the ROLE_SUBADMIN is a member.
		         * @summary Get a Role
		         * @param {string} id ID of the Role
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getRole: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getRole(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         *
		         * @summary Identities assigned a Role
		         * @param {string} id ID of the Role for which the assigned Identities are to be listed
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **aliasName**: *eq, sw*  **email**: *eq, sw*  **name**: *eq, sw, co*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **id, name, aliasName, email**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getRoleAssignedIdentities: function (id, limit, offset, count, filters, sorters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getRoleAssignedIdentities(id, limit, offset, count, filters, sorters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API lists the Entitlements associated with a given role.  A token with API, ORG_ADMIN, ROLE_ADMIN, or ROLE_SUBADMIN authority is required to call this API.
		         * @summary List role\'s Entitlements
		         * @param {string} id ID of the containing role
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **name**: *eq, sw*  **attribute**: *eq, sw*  **value**: *eq, sw*  **created**: *gt, lt, ge, le*  **modified**: *gt, lt, ge, le*  **owner.id**: *eq, in*  **source.id**: *eq, in*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name, attribute, value, created, modified**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getRoleEntitlements: function (id, limit, offset, count, filters, sorters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getRoleEntitlements(id, limit, offset, count, filters, sorters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns a list of Roles.  A token with API, ORG_ADMIN, ROLE_ADMIN, or ROLE_SUBADMIN authority is required to call this API.
		         * @summary List Roles
		         * @param {string} [forSubadmin] If provided, filters the returned list according to what is visible to the indicated ROLE_SUBADMIN Identity. The value of the parameter is either an Identity ID, or the special value **me**, which is shorthand for the calling Identity\&#39;s ID. A 400 Bad Request error is returned if the **for-subadmin** parameter is specified for an Identity that is not a subadmin.
		         * @param {number} [limit] Note that for this API the maximum value for limit is 50. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **name**: *eq, sw*  **created**: *gt, lt, ge, le*  **modified**: *gt, lt, ge, le*  **owner.id**: *eq, in*  **requestable**: *eq*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name, created, modified**
		         * @param {string} [forSegmentIds] If present and not empty, additionally filters Roles to those which are assigned to the Segment(s) with the specified IDs.  If segmentation is currently unavailable, specifying this parameter results in an error.
		         * @param {boolean} [includeUnsegmented] Whether or not the response list should contain unsegmented Roles. If *for-segment-ids* is absent or empty, specifying *include-unsegmented* as false results in an error.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listRoles: function (forSubadmin, limit, offset, count, filters, sorters, forSegmentIds, includeUnsegmented, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listRoles(forSubadmin, limit, offset, count, filters, sorters, forSegmentIds, includeUnsegmented, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API updates an existing Role using [JSON Patch](https://tools.ietf.org/html/rfc6902) syntax.  The following fields are patchable: **name**, **description**, **enabled**, **owner**, **accessProfiles**, **membership**, **requestable**, **accessRequestConfig**, **revokeRequestConfig**, **segments** A token with API, ORG_ADMIN, ROLE_ADMIN, or ROLE_SUBADMIN authority is required to call this API. In addition, a token with ROLE_SUBADMIN authority may only call this API if all Access Profiles included in the Role are associated to Sources with management workgroups of which the ROLE_SUBADMIN is a member. The maximum supported length for the description field is 2000 characters. Longer descriptions will be preserved for existing roles, however, any new roles as well as any updates to existing descriptions will be limited to 2000 characters.
		         * @summary Patch a specified Role
		         * @param {string} id ID of the Role to patch
		         * @param {Array<JsonPatchOperationBeta>} jsonPatchOperationBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchRole: function (id, jsonPatchOperationBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.patchRole(id, jsonPatchOperationBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.RolesBetaApiFp = RolesBetaApiFp;
		/**
		 * RolesBetaApi - factory interface
		 * @export
		 */
		var RolesBetaApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.RolesBetaApiFp)(configuration);
		    return {
		        /**
		         * This API initiates a bulk deletion of one or more Roles.  A token with API, ORG_ADMIN, ROLE_ADMIN, or ROLE_SUBADMIN authority is required to call this API. In addition, a token with ROLE_SUBADMIN authority may only call this API if all Roles included in the request are associated to Sources with management workgroups of which the ROLE_SUBADMIN is a member.
		         * @summary Delete Role(s)
		         * @param {RoleBulkDeleteRequestBeta} roleBulkDeleteRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        bulkDeleteRoles: function (roleBulkDeleteRequestBeta, axiosOptions) {
		            return localVarFp.bulkDeleteRoles(roleBulkDeleteRequestBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API creates a role. You must have a token with API, ORG_ADMIN, ROLE_ADMIN, or ROLE_SUBADMIN authority to call this API.  In addition, a ROLE_SUBADMIN may not create a role including an access profile if that access profile is associated with a source the ROLE_SUBADMIN is not associated with themselves.  The maximum supported length for the description field is 2000 characters. Longer descriptions will be preserved for existing roles. However, any new roles as well as any updates to existing descriptions will be limited to 2000 characters.
		         * @summary Create a Role
		         * @param {RoleBeta} roleBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createRole: function (roleBeta, axiosOptions) {
		            return localVarFp.createRole(roleBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API deletes a Role by its ID. A token with API, ORG_ADMIN, ROLE_ADMIN, or ROLE_SUBADMIN authority is required to call this API. In addition, a token with ROLE_SUBADMIN authority may only call this API if all Access Profiles included in the Role are associated to Sources with management workgroups of which the ROLE_SUBADMIN is a member.
		         * @summary Delete a Role
		         * @param {string} id ID of the Role
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteRole: function (id, axiosOptions) {
		            return localVarFp.deleteRole(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API returns a Role by its ID.  A token with API, ORG_ADMIN, ROLE_ADMIN, or ROLE_SUBADMIN authority is required to call this API. In addition, a token with ROLE_SUBADMIN authority may only call this API if all Access Profiles included in the Role are associated to Sources with management workgroups of which the ROLE_SUBADMIN is a member.
		         * @summary Get a Role
		         * @param {string} id ID of the Role
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getRole: function (id, axiosOptions) {
		            return localVarFp.getRole(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         *
		         * @summary Identities assigned a Role
		         * @param {string} id ID of the Role for which the assigned Identities are to be listed
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **aliasName**: *eq, sw*  **email**: *eq, sw*  **name**: *eq, sw, co*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **id, name, aliasName, email**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getRoleAssignedIdentities: function (id, limit, offset, count, filters, sorters, axiosOptions) {
		            return localVarFp.getRoleAssignedIdentities(id, limit, offset, count, filters, sorters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API lists the Entitlements associated with a given role.  A token with API, ORG_ADMIN, ROLE_ADMIN, or ROLE_SUBADMIN authority is required to call this API.
		         * @summary List role\'s Entitlements
		         * @param {string} id ID of the containing role
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **name**: *eq, sw*  **attribute**: *eq, sw*  **value**: *eq, sw*  **created**: *gt, lt, ge, le*  **modified**: *gt, lt, ge, le*  **owner.id**: *eq, in*  **source.id**: *eq, in*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name, attribute, value, created, modified**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getRoleEntitlements: function (id, limit, offset, count, filters, sorters, axiosOptions) {
		            return localVarFp.getRoleEntitlements(id, limit, offset, count, filters, sorters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API returns a list of Roles.  A token with API, ORG_ADMIN, ROLE_ADMIN, or ROLE_SUBADMIN authority is required to call this API.
		         * @summary List Roles
		         * @param {string} [forSubadmin] If provided, filters the returned list according to what is visible to the indicated ROLE_SUBADMIN Identity. The value of the parameter is either an Identity ID, or the special value **me**, which is shorthand for the calling Identity\&#39;s ID. A 400 Bad Request error is returned if the **for-subadmin** parameter is specified for an Identity that is not a subadmin.
		         * @param {number} [limit] Note that for this API the maximum value for limit is 50. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **name**: *eq, sw*  **created**: *gt, lt, ge, le*  **modified**: *gt, lt, ge, le*  **owner.id**: *eq, in*  **requestable**: *eq*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name, created, modified**
		         * @param {string} [forSegmentIds] If present and not empty, additionally filters Roles to those which are assigned to the Segment(s) with the specified IDs.  If segmentation is currently unavailable, specifying this parameter results in an error.
		         * @param {boolean} [includeUnsegmented] Whether or not the response list should contain unsegmented Roles. If *for-segment-ids* is absent or empty, specifying *include-unsegmented* as false results in an error.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listRoles: function (forSubadmin, limit, offset, count, filters, sorters, forSegmentIds, includeUnsegmented, axiosOptions) {
		            return localVarFp.listRoles(forSubadmin, limit, offset, count, filters, sorters, forSegmentIds, includeUnsegmented, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API updates an existing Role using [JSON Patch](https://tools.ietf.org/html/rfc6902) syntax.  The following fields are patchable: **name**, **description**, **enabled**, **owner**, **accessProfiles**, **membership**, **requestable**, **accessRequestConfig**, **revokeRequestConfig**, **segments** A token with API, ORG_ADMIN, ROLE_ADMIN, or ROLE_SUBADMIN authority is required to call this API. In addition, a token with ROLE_SUBADMIN authority may only call this API if all Access Profiles included in the Role are associated to Sources with management workgroups of which the ROLE_SUBADMIN is a member. The maximum supported length for the description field is 2000 characters. Longer descriptions will be preserved for existing roles, however, any new roles as well as any updates to existing descriptions will be limited to 2000 characters.
		         * @summary Patch a specified Role
		         * @param {string} id ID of the Role to patch
		         * @param {Array<JsonPatchOperationBeta>} jsonPatchOperationBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchRole: function (id, jsonPatchOperationBeta, axiosOptions) {
		            return localVarFp.patchRole(id, jsonPatchOperationBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.RolesBetaApiFactory = RolesBetaApiFactory;
		/**
		 * RolesBetaApi - object-oriented interface
		 * @export
		 * @class RolesBetaApi
		 * @extends {BaseAPI}
		 */
		var RolesBetaApi = /** @class */ (function (_super) {
		    __extends(RolesBetaApi, _super);
		    function RolesBetaApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * This API initiates a bulk deletion of one or more Roles.  A token with API, ORG_ADMIN, ROLE_ADMIN, or ROLE_SUBADMIN authority is required to call this API. In addition, a token with ROLE_SUBADMIN authority may only call this API if all Roles included in the request are associated to Sources with management workgroups of which the ROLE_SUBADMIN is a member.
		     * @summary Delete Role(s)
		     * @param {RolesBetaApiBulkDeleteRolesRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof RolesBetaApi
		     */
		    RolesBetaApi.prototype.bulkDeleteRoles = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.RolesBetaApiFp)(this.configuration).bulkDeleteRoles(requestParameters.roleBulkDeleteRequestBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API creates a role. You must have a token with API, ORG_ADMIN, ROLE_ADMIN, or ROLE_SUBADMIN authority to call this API.  In addition, a ROLE_SUBADMIN may not create a role including an access profile if that access profile is associated with a source the ROLE_SUBADMIN is not associated with themselves.  The maximum supported length for the description field is 2000 characters. Longer descriptions will be preserved for existing roles. However, any new roles as well as any updates to existing descriptions will be limited to 2000 characters.
		     * @summary Create a Role
		     * @param {RolesBetaApiCreateRoleRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof RolesBetaApi
		     */
		    RolesBetaApi.prototype.createRole = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.RolesBetaApiFp)(this.configuration).createRole(requestParameters.roleBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API deletes a Role by its ID. A token with API, ORG_ADMIN, ROLE_ADMIN, or ROLE_SUBADMIN authority is required to call this API. In addition, a token with ROLE_SUBADMIN authority may only call this API if all Access Profiles included in the Role are associated to Sources with management workgroups of which the ROLE_SUBADMIN is a member.
		     * @summary Delete a Role
		     * @param {RolesBetaApiDeleteRoleRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof RolesBetaApi
		     */
		    RolesBetaApi.prototype.deleteRole = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.RolesBetaApiFp)(this.configuration).deleteRole(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API returns a Role by its ID.  A token with API, ORG_ADMIN, ROLE_ADMIN, or ROLE_SUBADMIN authority is required to call this API. In addition, a token with ROLE_SUBADMIN authority may only call this API if all Access Profiles included in the Role are associated to Sources with management workgroups of which the ROLE_SUBADMIN is a member.
		     * @summary Get a Role
		     * @param {RolesBetaApiGetRoleRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof RolesBetaApi
		     */
		    RolesBetaApi.prototype.getRole = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.RolesBetaApiFp)(this.configuration).getRole(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     *
		     * @summary Identities assigned a Role
		     * @param {RolesBetaApiGetRoleAssignedIdentitiesRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof RolesBetaApi
		     */
		    RolesBetaApi.prototype.getRoleAssignedIdentities = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.RolesBetaApiFp)(this.configuration).getRoleAssignedIdentities(requestParameters.id, requestParameters.limit, requestParameters.offset, requestParameters.count, requestParameters.filters, requestParameters.sorters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API lists the Entitlements associated with a given role.  A token with API, ORG_ADMIN, ROLE_ADMIN, or ROLE_SUBADMIN authority is required to call this API.
		     * @summary List role\'s Entitlements
		     * @param {RolesBetaApiGetRoleEntitlementsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof RolesBetaApi
		     */
		    RolesBetaApi.prototype.getRoleEntitlements = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.RolesBetaApiFp)(this.configuration).getRoleEntitlements(requestParameters.id, requestParameters.limit, requestParameters.offset, requestParameters.count, requestParameters.filters, requestParameters.sorters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API returns a list of Roles.  A token with API, ORG_ADMIN, ROLE_ADMIN, or ROLE_SUBADMIN authority is required to call this API.
		     * @summary List Roles
		     * @param {RolesBetaApiListRolesRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof RolesBetaApi
		     */
		    RolesBetaApi.prototype.listRoles = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.RolesBetaApiFp)(this.configuration).listRoles(requestParameters.forSubadmin, requestParameters.limit, requestParameters.offset, requestParameters.count, requestParameters.filters, requestParameters.sorters, requestParameters.forSegmentIds, requestParameters.includeUnsegmented, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API updates an existing Role using [JSON Patch](https://tools.ietf.org/html/rfc6902) syntax.  The following fields are patchable: **name**, **description**, **enabled**, **owner**, **accessProfiles**, **membership**, **requestable**, **accessRequestConfig**, **revokeRequestConfig**, **segments** A token with API, ORG_ADMIN, ROLE_ADMIN, or ROLE_SUBADMIN authority is required to call this API. In addition, a token with ROLE_SUBADMIN authority may only call this API if all Access Profiles included in the Role are associated to Sources with management workgroups of which the ROLE_SUBADMIN is a member. The maximum supported length for the description field is 2000 characters. Longer descriptions will be preserved for existing roles, however, any new roles as well as any updates to existing descriptions will be limited to 2000 characters.
		     * @summary Patch a specified Role
		     * @param {RolesBetaApiPatchRoleRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof RolesBetaApi
		     */
		    RolesBetaApi.prototype.patchRole = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.RolesBetaApiFp)(this.configuration).patchRole(requestParameters.id, requestParameters.jsonPatchOperationBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return RolesBetaApi;
		}(base_1.BaseAPI));
		exports.RolesBetaApi = RolesBetaApi;
		/**
		 * SODPolicyBetaApi - axios parameter creator
		 * @export
		 */
		var SODPolicyBetaApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * This creates both General and Conflicting Access Based policy, with a limit of 50 entitlements for each (left & right) criteria for Conflicting Access Based SOD policy. Requires role of ORG_ADMIN.
		         * @summary Create SOD policy
		         * @param {SodPolicyBeta} sodPolicyBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        createSodPolicy: function (sodPolicyBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'sodPolicyBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('createSodPolicy', 'sodPolicyBeta', sodPolicyBeta);
		                            localVarPath = "/sod-policies";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(sodPolicyBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This deletes a specified SOD policy. Requires role of ORG_ADMIN.
		         * @summary Delete SOD policy by ID
		         * @param {string} id The ID of the SOD Policy to delete.
		         * @param {boolean} [logical] Indicates whether this is a soft delete (logical true) or a hard delete.
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        deleteSodPolicy: function (id, logical, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('deleteSodPolicy', 'id', id);
		                            localVarPath = "/sod-policies/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'DELETE' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (logical !== undefined) {
		                                localVarQueryParameter['logical'] = logical;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This deletes schedule for a specified SOD policy. Requires role of ORG_ADMIN.
		         * @summary Delete SOD policy schedule
		         * @param {string} id The ID of the SOD policy the schedule must be deleted for.
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        deleteSodPolicySchedule: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('deleteSodPolicySchedule', 'id', id);
		                            localVarPath = "/sod-policies/{id}/schedule"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'DELETE' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This allows to download a specified named violation report for a given report reference. Requires role of ORG_ADMIN.
		         * @summary Download custom violation report
		         * @param {string} reportResultId The ID of the report reference to download.
		         * @param {string} fileName Custom Name for the  file.
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        getCustomViolationReport: function (reportResultId, fileName, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'reportResultId' is not null or undefined
		                            (0, common_1.assertParamExists)('getCustomViolationReport', 'reportResultId', reportResultId);
		                            // verify required parameter 'fileName' is not null or undefined
		                            (0, common_1.assertParamExists)('getCustomViolationReport', 'fileName', fileName);
		                            localVarPath = "/sod-violation-report/{reportResultId}/download/{fileName}"
		                                .replace("{".concat("reportResultId", "}"), encodeURIComponent(String(reportResultId)))
		                                .replace("{".concat("fileName", "}"), encodeURIComponent(String(fileName)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This allows to download a violation report for a given report reference. Requires role of ORG_ADMIN.
		         * @summary Download violation report
		         * @param {string} reportResultId The ID of the report reference to download.
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        getDefaultViolationReport: function (reportResultId, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'reportResultId' is not null or undefined
		                            (0, common_1.assertParamExists)('getDefaultViolationReport', 'reportResultId', reportResultId);
		                            localVarPath = "/sod-violation-report/{reportResultId}/download"
		                                .replace("{".concat("reportResultId", "}"), encodeURIComponent(String(reportResultId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This endpoint gets the status for a violation report for all policy run. Requires role of ORG_ADMIN.
		         * @summary Get multi-report run task status
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        getSodAllReportRunStatus: function (axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/sod-violation-report";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets specified SOD policy. Requires role of ORG_ADMIN.
		         * @summary Get SOD policy by ID
		         * @param {string} id The ID of the object reference to retrieve.
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        getSodPolicy: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getSodPolicy', 'id', id);
		                            localVarPath = "/sod-policies/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This endpoint gets a specified SOD policy\'s schedule. Requires the role of ORG_ADMIN.
		         * @summary Get SOD policy schedule
		         * @param {string} id The ID of the object reference to retrieve.
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        getSodPolicySchedule: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getSodPolicySchedule', 'id', id);
		                            localVarPath = "/sod-policies/{id}/schedule"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets the status for a violation report run task that has already been invoked. Requires role of ORG_ADMIN.
		         * @summary Get violation report run status
		         * @param {string} reportResultId The ID of the report reference to retrieve.
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        getSodViolationReportRunStatus: function (reportResultId, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'reportResultId' is not null or undefined
		                            (0, common_1.assertParamExists)('getSodViolationReportRunStatus', 'reportResultId', reportResultId);
		                            localVarPath = "/sod-policies/sod-violation-report-status/{reportResultId}"
		                                .replace("{".concat("reportResultId", "}"), encodeURIComponent(String(reportResultId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets the status for a violation report run task that has already been invoked. Requires role of ORG_ADMIN.
		         * @summary Get SOD violation report status
		         * @param {string} id The ID of the object reference to retrieve.
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        getSodViolationReportStatus: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getSodViolationReportStatus', 'id', id);
		                            localVarPath = "/sod-policies/{id}/violation-report"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets list of all SOD policies. Requires role of ORG_ADMIN
		         * @summary List SOD policies
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq*  **name**: *eq*  **state**: *eq*
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        listSodPolicies: function (limit, offset, count, filters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/sod-policies";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Allows updating SOD Policy fields other than [\"id\",\"created\",\"creatorId\",\"policyQuery\",\"type\"] using the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard. Requires role of ORG_ADMIN. This endpoint can only patch CONFLICTING_ACCESS_BASED type policies. Do not use this endpoint to patch general policies - doing so will build an API exception.
		         * @summary Patch a SOD policy
		         * @param {string} id The ID of the SOD policy being modified.
		         * @param {Array<object>} requestBody A list of SOD Policy update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.  The following fields are patchable: * name * description * ownerRef * externalPolicyReference * compensatingControls * correctionAdvice * state * tags * violationOwnerAssignmentConfig * scheduled * conflictingAccessCriteria
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        patchSodPolicy: function (id, requestBody, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('patchSodPolicy', 'id', id);
		                            // verify required parameter 'requestBody' is not null or undefined
		                            (0, common_1.assertParamExists)('patchSodPolicy', 'requestBody', requestBody);
		                            localVarPath = "/sod-policies/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PATCH' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json-patch+json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(requestBody, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This updates schedule for a specified SOD policy. Requires role of ORG_ADMIN.
		         * @summary Update SOD Policy schedule
		         * @param {string} id The ID of the SOD policy to update its schedule.
		         * @param {SodPolicyScheduleBeta} sodPolicyScheduleBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        putPolicySchedule: function (id, sodPolicyScheduleBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('putPolicySchedule', 'id', id);
		                            // verify required parameter 'sodPolicyScheduleBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('putPolicySchedule', 'sodPolicyScheduleBeta', sodPolicyScheduleBeta);
		                            localVarPath = "/sod-policies/{id}/schedule"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PUT' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(sodPolicyScheduleBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This updates a specified SOD policy. Requires role of ORG_ADMIN.
		         * @summary Update SOD policy by ID
		         * @param {string} id The ID of the SOD policy to update.
		         * @param {SodPolicyBeta} sodPolicyBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        putSodPolicy: function (id, sodPolicyBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('putSodPolicy', 'id', id);
		                            // verify required parameter 'sodPolicyBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('putSodPolicy', 'sodPolicyBeta', sodPolicyBeta);
		                            localVarPath = "/sod-policies/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PUT' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(sodPolicyBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Runs multi-policy report for the org. If a policy reports more than 5000 violations, the report mentions that the violation limit was exceeded for that policy. If the request is empty, the report runs for all policies. Otherwise, the report runs for only the filtered policy list provided. Requires role of ORG_ADMIN.
		         * @summary Runs all policies for org
		         * @param {MultiPolicyRequestBeta} [multiPolicyRequestBeta]
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        startSodAllPoliciesForOrg: function (multiPolicyRequestBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/sod-violation-report/run";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(multiPolicyRequestBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This invokes processing of violation report for given SOD policy. If the policy reports more than 5000 violations, the report returns with violation limit exceeded message. Requires role of ORG_ADMIN.
		         * @summary Runs SOD policy violation report
		         * @param {string} id The SOD policy ID to run.
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        startSodPolicy: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('startSodPolicy', 'id', id);
		                            localVarPath = "/sod-policies/{id}/violation-report/run"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.SODPolicyBetaApiAxiosParamCreator = SODPolicyBetaApiAxiosParamCreator;
		/**
		 * SODPolicyBetaApi - functional programming interface
		 * @export
		 */
		var SODPolicyBetaApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.SODPolicyBetaApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * This creates both General and Conflicting Access Based policy, with a limit of 50 entitlements for each (left & right) criteria for Conflicting Access Based SOD policy. Requires role of ORG_ADMIN.
		         * @summary Create SOD policy
		         * @param {SodPolicyBeta} sodPolicyBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        createSodPolicy: function (sodPolicyBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.createSodPolicy(sodPolicyBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This deletes a specified SOD policy. Requires role of ORG_ADMIN.
		         * @summary Delete SOD policy by ID
		         * @param {string} id The ID of the SOD Policy to delete.
		         * @param {boolean} [logical] Indicates whether this is a soft delete (logical true) or a hard delete.
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        deleteSodPolicy: function (id, logical, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.deleteSodPolicy(id, logical, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This deletes schedule for a specified SOD policy. Requires role of ORG_ADMIN.
		         * @summary Delete SOD policy schedule
		         * @param {string} id The ID of the SOD policy the schedule must be deleted for.
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        deleteSodPolicySchedule: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.deleteSodPolicySchedule(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This allows to download a specified named violation report for a given report reference. Requires role of ORG_ADMIN.
		         * @summary Download custom violation report
		         * @param {string} reportResultId The ID of the report reference to download.
		         * @param {string} fileName Custom Name for the  file.
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        getCustomViolationReport: function (reportResultId, fileName, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getCustomViolationReport(reportResultId, fileName, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This allows to download a violation report for a given report reference. Requires role of ORG_ADMIN.
		         * @summary Download violation report
		         * @param {string} reportResultId The ID of the report reference to download.
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        getDefaultViolationReport: function (reportResultId, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getDefaultViolationReport(reportResultId, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This endpoint gets the status for a violation report for all policy run. Requires role of ORG_ADMIN.
		         * @summary Get multi-report run task status
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        getSodAllReportRunStatus: function (axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getSodAllReportRunStatus(axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets specified SOD policy. Requires role of ORG_ADMIN.
		         * @summary Get SOD policy by ID
		         * @param {string} id The ID of the object reference to retrieve.
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        getSodPolicy: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getSodPolicy(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This endpoint gets a specified SOD policy\'s schedule. Requires the role of ORG_ADMIN.
		         * @summary Get SOD policy schedule
		         * @param {string} id The ID of the object reference to retrieve.
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        getSodPolicySchedule: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getSodPolicySchedule(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets the status for a violation report run task that has already been invoked. Requires role of ORG_ADMIN.
		         * @summary Get violation report run status
		         * @param {string} reportResultId The ID of the report reference to retrieve.
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        getSodViolationReportRunStatus: function (reportResultId, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getSodViolationReportRunStatus(reportResultId, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets the status for a violation report run task that has already been invoked. Requires role of ORG_ADMIN.
		         * @summary Get SOD violation report status
		         * @param {string} id The ID of the object reference to retrieve.
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        getSodViolationReportStatus: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getSodViolationReportStatus(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets list of all SOD policies. Requires role of ORG_ADMIN
		         * @summary List SOD policies
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq*  **name**: *eq*  **state**: *eq*
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        listSodPolicies: function (limit, offset, count, filters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listSodPolicies(limit, offset, count, filters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Allows updating SOD Policy fields other than [\"id\",\"created\",\"creatorId\",\"policyQuery\",\"type\"] using the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard. Requires role of ORG_ADMIN. This endpoint can only patch CONFLICTING_ACCESS_BASED type policies. Do not use this endpoint to patch general policies - doing so will build an API exception.
		         * @summary Patch a SOD policy
		         * @param {string} id The ID of the SOD policy being modified.
		         * @param {Array<object>} requestBody A list of SOD Policy update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.  The following fields are patchable: * name * description * ownerRef * externalPolicyReference * compensatingControls * correctionAdvice * state * tags * violationOwnerAssignmentConfig * scheduled * conflictingAccessCriteria
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        patchSodPolicy: function (id, requestBody, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.patchSodPolicy(id, requestBody, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This updates schedule for a specified SOD policy. Requires role of ORG_ADMIN.
		         * @summary Update SOD Policy schedule
		         * @param {string} id The ID of the SOD policy to update its schedule.
		         * @param {SodPolicyScheduleBeta} sodPolicyScheduleBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        putPolicySchedule: function (id, sodPolicyScheduleBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.putPolicySchedule(id, sodPolicyScheduleBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This updates a specified SOD policy. Requires role of ORG_ADMIN.
		         * @summary Update SOD policy by ID
		         * @param {string} id The ID of the SOD policy to update.
		         * @param {SodPolicyBeta} sodPolicyBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        putSodPolicy: function (id, sodPolicyBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.putSodPolicy(id, sodPolicyBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Runs multi-policy report for the org. If a policy reports more than 5000 violations, the report mentions that the violation limit was exceeded for that policy. If the request is empty, the report runs for all policies. Otherwise, the report runs for only the filtered policy list provided. Requires role of ORG_ADMIN.
		         * @summary Runs all policies for org
		         * @param {MultiPolicyRequestBeta} [multiPolicyRequestBeta]
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        startSodAllPoliciesForOrg: function (multiPolicyRequestBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.startSodAllPoliciesForOrg(multiPolicyRequestBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This invokes processing of violation report for given SOD policy. If the policy reports more than 5000 violations, the report returns with violation limit exceeded message. Requires role of ORG_ADMIN.
		         * @summary Runs SOD policy violation report
		         * @param {string} id The SOD policy ID to run.
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        startSodPolicy: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.startSodPolicy(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.SODPolicyBetaApiFp = SODPolicyBetaApiFp;
		/**
		 * SODPolicyBetaApi - factory interface
		 * @export
		 */
		var SODPolicyBetaApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.SODPolicyBetaApiFp)(configuration);
		    return {
		        /**
		         * This creates both General and Conflicting Access Based policy, with a limit of 50 entitlements for each (left & right) criteria for Conflicting Access Based SOD policy. Requires role of ORG_ADMIN.
		         * @summary Create SOD policy
		         * @param {SodPolicyBeta} sodPolicyBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        createSodPolicy: function (sodPolicyBeta, axiosOptions) {
		            return localVarFp.createSodPolicy(sodPolicyBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This deletes a specified SOD policy. Requires role of ORG_ADMIN.
		         * @summary Delete SOD policy by ID
		         * @param {string} id The ID of the SOD Policy to delete.
		         * @param {boolean} [logical] Indicates whether this is a soft delete (logical true) or a hard delete.
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        deleteSodPolicy: function (id, logical, axiosOptions) {
		            return localVarFp.deleteSodPolicy(id, logical, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This deletes schedule for a specified SOD policy. Requires role of ORG_ADMIN.
		         * @summary Delete SOD policy schedule
		         * @param {string} id The ID of the SOD policy the schedule must be deleted for.
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        deleteSodPolicySchedule: function (id, axiosOptions) {
		            return localVarFp.deleteSodPolicySchedule(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This allows to download a specified named violation report for a given report reference. Requires role of ORG_ADMIN.
		         * @summary Download custom violation report
		         * @param {string} reportResultId The ID of the report reference to download.
		         * @param {string} fileName Custom Name for the  file.
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        getCustomViolationReport: function (reportResultId, fileName, axiosOptions) {
		            return localVarFp.getCustomViolationReport(reportResultId, fileName, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This allows to download a violation report for a given report reference. Requires role of ORG_ADMIN.
		         * @summary Download violation report
		         * @param {string} reportResultId The ID of the report reference to download.
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        getDefaultViolationReport: function (reportResultId, axiosOptions) {
		            return localVarFp.getDefaultViolationReport(reportResultId, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This endpoint gets the status for a violation report for all policy run. Requires role of ORG_ADMIN.
		         * @summary Get multi-report run task status
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        getSodAllReportRunStatus: function (axiosOptions) {
		            return localVarFp.getSodAllReportRunStatus(axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This gets specified SOD policy. Requires role of ORG_ADMIN.
		         * @summary Get SOD policy by ID
		         * @param {string} id The ID of the object reference to retrieve.
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        getSodPolicy: function (id, axiosOptions) {
		            return localVarFp.getSodPolicy(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This endpoint gets a specified SOD policy\'s schedule. Requires the role of ORG_ADMIN.
		         * @summary Get SOD policy schedule
		         * @param {string} id The ID of the object reference to retrieve.
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        getSodPolicySchedule: function (id, axiosOptions) {
		            return localVarFp.getSodPolicySchedule(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This gets the status for a violation report run task that has already been invoked. Requires role of ORG_ADMIN.
		         * @summary Get violation report run status
		         * @param {string} reportResultId The ID of the report reference to retrieve.
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        getSodViolationReportRunStatus: function (reportResultId, axiosOptions) {
		            return localVarFp.getSodViolationReportRunStatus(reportResultId, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This gets the status for a violation report run task that has already been invoked. Requires role of ORG_ADMIN.
		         * @summary Get SOD violation report status
		         * @param {string} id The ID of the object reference to retrieve.
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        getSodViolationReportStatus: function (id, axiosOptions) {
		            return localVarFp.getSodViolationReportStatus(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This gets list of all SOD policies. Requires role of ORG_ADMIN
		         * @summary List SOD policies
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq*  **name**: *eq*  **state**: *eq*
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        listSodPolicies: function (limit, offset, count, filters, axiosOptions) {
		            return localVarFp.listSodPolicies(limit, offset, count, filters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Allows updating SOD Policy fields other than [\"id\",\"created\",\"creatorId\",\"policyQuery\",\"type\"] using the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard. Requires role of ORG_ADMIN. This endpoint can only patch CONFLICTING_ACCESS_BASED type policies. Do not use this endpoint to patch general policies - doing so will build an API exception.
		         * @summary Patch a SOD policy
		         * @param {string} id The ID of the SOD policy being modified.
		         * @param {Array<object>} requestBody A list of SOD Policy update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.  The following fields are patchable: * name * description * ownerRef * externalPolicyReference * compensatingControls * correctionAdvice * state * tags * violationOwnerAssignmentConfig * scheduled * conflictingAccessCriteria
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        patchSodPolicy: function (id, requestBody, axiosOptions) {
		            return localVarFp.patchSodPolicy(id, requestBody, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This updates schedule for a specified SOD policy. Requires role of ORG_ADMIN.
		         * @summary Update SOD Policy schedule
		         * @param {string} id The ID of the SOD policy to update its schedule.
		         * @param {SodPolicyScheduleBeta} sodPolicyScheduleBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        putPolicySchedule: function (id, sodPolicyScheduleBeta, axiosOptions) {
		            return localVarFp.putPolicySchedule(id, sodPolicyScheduleBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This updates a specified SOD policy. Requires role of ORG_ADMIN.
		         * @summary Update SOD policy by ID
		         * @param {string} id The ID of the SOD policy to update.
		         * @param {SodPolicyBeta} sodPolicyBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        putSodPolicy: function (id, sodPolicyBeta, axiosOptions) {
		            return localVarFp.putSodPolicy(id, sodPolicyBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Runs multi-policy report for the org. If a policy reports more than 5000 violations, the report mentions that the violation limit was exceeded for that policy. If the request is empty, the report runs for all policies. Otherwise, the report runs for only the filtered policy list provided. Requires role of ORG_ADMIN.
		         * @summary Runs all policies for org
		         * @param {MultiPolicyRequestBeta} [multiPolicyRequestBeta]
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        startSodAllPoliciesForOrg: function (multiPolicyRequestBeta, axiosOptions) {
		            return localVarFp.startSodAllPoliciesForOrg(multiPolicyRequestBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This invokes processing of violation report for given SOD policy. If the policy reports more than 5000 violations, the report returns with violation limit exceeded message. Requires role of ORG_ADMIN.
		         * @summary Runs SOD policy violation report
		         * @param {string} id The SOD policy ID to run.
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        startSodPolicy: function (id, axiosOptions) {
		            return localVarFp.startSodPolicy(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.SODPolicyBetaApiFactory = SODPolicyBetaApiFactory;
		/**
		 * SODPolicyBetaApi - object-oriented interface
		 * @export
		 * @class SODPolicyBetaApi
		 * @extends {BaseAPI}
		 */
		var SODPolicyBetaApi = /** @class */ (function (_super) {
		    __extends(SODPolicyBetaApi, _super);
		    function SODPolicyBetaApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * This creates both General and Conflicting Access Based policy, with a limit of 50 entitlements for each (left & right) criteria for Conflicting Access Based SOD policy. Requires role of ORG_ADMIN.
		     * @summary Create SOD policy
		     * @param {SODPolicyBetaApiCreateSodPolicyRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @deprecated
		     * @throws {RequiredError}
		     * @memberof SODPolicyBetaApi
		     */
		    SODPolicyBetaApi.prototype.createSodPolicy = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SODPolicyBetaApiFp)(this.configuration).createSodPolicy(requestParameters.sodPolicyBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This deletes a specified SOD policy. Requires role of ORG_ADMIN.
		     * @summary Delete SOD policy by ID
		     * @param {SODPolicyBetaApiDeleteSodPolicyRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @deprecated
		     * @throws {RequiredError}
		     * @memberof SODPolicyBetaApi
		     */
		    SODPolicyBetaApi.prototype.deleteSodPolicy = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SODPolicyBetaApiFp)(this.configuration).deleteSodPolicy(requestParameters.id, requestParameters.logical, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This deletes schedule for a specified SOD policy. Requires role of ORG_ADMIN.
		     * @summary Delete SOD policy schedule
		     * @param {SODPolicyBetaApiDeleteSodPolicyScheduleRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @deprecated
		     * @throws {RequiredError}
		     * @memberof SODPolicyBetaApi
		     */
		    SODPolicyBetaApi.prototype.deleteSodPolicySchedule = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SODPolicyBetaApiFp)(this.configuration).deleteSodPolicySchedule(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This allows to download a specified named violation report for a given report reference. Requires role of ORG_ADMIN.
		     * @summary Download custom violation report
		     * @param {SODPolicyBetaApiGetCustomViolationReportRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @deprecated
		     * @throws {RequiredError}
		     * @memberof SODPolicyBetaApi
		     */
		    SODPolicyBetaApi.prototype.getCustomViolationReport = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SODPolicyBetaApiFp)(this.configuration).getCustomViolationReport(requestParameters.reportResultId, requestParameters.fileName, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This allows to download a violation report for a given report reference. Requires role of ORG_ADMIN.
		     * @summary Download violation report
		     * @param {SODPolicyBetaApiGetDefaultViolationReportRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @deprecated
		     * @throws {RequiredError}
		     * @memberof SODPolicyBetaApi
		     */
		    SODPolicyBetaApi.prototype.getDefaultViolationReport = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SODPolicyBetaApiFp)(this.configuration).getDefaultViolationReport(requestParameters.reportResultId, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This endpoint gets the status for a violation report for all policy run. Requires role of ORG_ADMIN.
		     * @summary Get multi-report run task status
		     * @param {*} [axiosOptions] Override http request option.
		     * @deprecated
		     * @throws {RequiredError}
		     * @memberof SODPolicyBetaApi
		     */
		    SODPolicyBetaApi.prototype.getSodAllReportRunStatus = function (axiosOptions) {
		        var _this = this;
		        return (0, exports.SODPolicyBetaApiFp)(this.configuration).getSodAllReportRunStatus(axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This gets specified SOD policy. Requires role of ORG_ADMIN.
		     * @summary Get SOD policy by ID
		     * @param {SODPolicyBetaApiGetSodPolicyRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @deprecated
		     * @throws {RequiredError}
		     * @memberof SODPolicyBetaApi
		     */
		    SODPolicyBetaApi.prototype.getSodPolicy = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SODPolicyBetaApiFp)(this.configuration).getSodPolicy(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This endpoint gets a specified SOD policy\'s schedule. Requires the role of ORG_ADMIN.
		     * @summary Get SOD policy schedule
		     * @param {SODPolicyBetaApiGetSodPolicyScheduleRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @deprecated
		     * @throws {RequiredError}
		     * @memberof SODPolicyBetaApi
		     */
		    SODPolicyBetaApi.prototype.getSodPolicySchedule = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SODPolicyBetaApiFp)(this.configuration).getSodPolicySchedule(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This gets the status for a violation report run task that has already been invoked. Requires role of ORG_ADMIN.
		     * @summary Get violation report run status
		     * @param {SODPolicyBetaApiGetSodViolationReportRunStatusRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @deprecated
		     * @throws {RequiredError}
		     * @memberof SODPolicyBetaApi
		     */
		    SODPolicyBetaApi.prototype.getSodViolationReportRunStatus = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SODPolicyBetaApiFp)(this.configuration).getSodViolationReportRunStatus(requestParameters.reportResultId, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This gets the status for a violation report run task that has already been invoked. Requires role of ORG_ADMIN.
		     * @summary Get SOD violation report status
		     * @param {SODPolicyBetaApiGetSodViolationReportStatusRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @deprecated
		     * @throws {RequiredError}
		     * @memberof SODPolicyBetaApi
		     */
		    SODPolicyBetaApi.prototype.getSodViolationReportStatus = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SODPolicyBetaApiFp)(this.configuration).getSodViolationReportStatus(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This gets list of all SOD policies. Requires role of ORG_ADMIN
		     * @summary List SOD policies
		     * @param {SODPolicyBetaApiListSodPoliciesRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @deprecated
		     * @throws {RequiredError}
		     * @memberof SODPolicyBetaApi
		     */
		    SODPolicyBetaApi.prototype.listSodPolicies = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.SODPolicyBetaApiFp)(this.configuration).listSodPolicies(requestParameters.limit, requestParameters.offset, requestParameters.count, requestParameters.filters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Allows updating SOD Policy fields other than [\"id\",\"created\",\"creatorId\",\"policyQuery\",\"type\"] using the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard. Requires role of ORG_ADMIN. This endpoint can only patch CONFLICTING_ACCESS_BASED type policies. Do not use this endpoint to patch general policies - doing so will build an API exception.
		     * @summary Patch a SOD policy
		     * @param {SODPolicyBetaApiPatchSodPolicyRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @deprecated
		     * @throws {RequiredError}
		     * @memberof SODPolicyBetaApi
		     */
		    SODPolicyBetaApi.prototype.patchSodPolicy = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SODPolicyBetaApiFp)(this.configuration).patchSodPolicy(requestParameters.id, requestParameters.requestBody, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This updates schedule for a specified SOD policy. Requires role of ORG_ADMIN.
		     * @summary Update SOD Policy schedule
		     * @param {SODPolicyBetaApiPutPolicyScheduleRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @deprecated
		     * @throws {RequiredError}
		     * @memberof SODPolicyBetaApi
		     */
		    SODPolicyBetaApi.prototype.putPolicySchedule = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SODPolicyBetaApiFp)(this.configuration).putPolicySchedule(requestParameters.id, requestParameters.sodPolicyScheduleBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This updates a specified SOD policy. Requires role of ORG_ADMIN.
		     * @summary Update SOD policy by ID
		     * @param {SODPolicyBetaApiPutSodPolicyRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @deprecated
		     * @throws {RequiredError}
		     * @memberof SODPolicyBetaApi
		     */
		    SODPolicyBetaApi.prototype.putSodPolicy = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SODPolicyBetaApiFp)(this.configuration).putSodPolicy(requestParameters.id, requestParameters.sodPolicyBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Runs multi-policy report for the org. If a policy reports more than 5000 violations, the report mentions that the violation limit was exceeded for that policy. If the request is empty, the report runs for all policies. Otherwise, the report runs for only the filtered policy list provided. Requires role of ORG_ADMIN.
		     * @summary Runs all policies for org
		     * @param {SODPolicyBetaApiStartSodAllPoliciesForOrgRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @deprecated
		     * @throws {RequiredError}
		     * @memberof SODPolicyBetaApi
		     */
		    SODPolicyBetaApi.prototype.startSodAllPoliciesForOrg = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.SODPolicyBetaApiFp)(this.configuration).startSodAllPoliciesForOrg(requestParameters.multiPolicyRequestBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This invokes processing of violation report for given SOD policy. If the policy reports more than 5000 violations, the report returns with violation limit exceeded message. Requires role of ORG_ADMIN.
		     * @summary Runs SOD policy violation report
		     * @param {SODPolicyBetaApiStartSodPolicyRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @deprecated
		     * @throws {RequiredError}
		     * @memberof SODPolicyBetaApi
		     */
		    SODPolicyBetaApi.prototype.startSodPolicy = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SODPolicyBetaApiFp)(this.configuration).startSodPolicy(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return SODPolicyBetaApi;
		}(base_1.BaseAPI));
		exports.SODPolicyBetaApi = SODPolicyBetaApi;
		/**
		 * SODViolationsBetaApi - axios parameter creator
		 * @export
		 */
		var SODViolationsBetaApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * This API is used to check if granting some additional accesses would cause the subject to be in violation of any SOD policies. Returns the violations that would be caused.  A token with ORG_ADMIN or API authority is required to call this API.
		         * @summary Predict SOD violations for identity.
		         * @param {IdentityWithNewAccessBeta} identityWithNewAccessBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        startPredictSodViolations: function (identityWithNewAccessBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'identityWithNewAccessBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('startPredictSodViolations', 'identityWithNewAccessBeta', identityWithNewAccessBeta);
		                            localVarPath = "/sod-violations/predict";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(identityWithNewAccessBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.SODViolationsBetaApiAxiosParamCreator = SODViolationsBetaApiAxiosParamCreator;
		/**
		 * SODViolationsBetaApi - functional programming interface
		 * @export
		 */
		var SODViolationsBetaApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.SODViolationsBetaApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * This API is used to check if granting some additional accesses would cause the subject to be in violation of any SOD policies. Returns the violations that would be caused.  A token with ORG_ADMIN or API authority is required to call this API.
		         * @summary Predict SOD violations for identity.
		         * @param {IdentityWithNewAccessBeta} identityWithNewAccessBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        startPredictSodViolations: function (identityWithNewAccessBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.startPredictSodViolations(identityWithNewAccessBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.SODViolationsBetaApiFp = SODViolationsBetaApiFp;
		/**
		 * SODViolationsBetaApi - factory interface
		 * @export
		 */
		var SODViolationsBetaApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.SODViolationsBetaApiFp)(configuration);
		    return {
		        /**
		         * This API is used to check if granting some additional accesses would cause the subject to be in violation of any SOD policies. Returns the violations that would be caused.  A token with ORG_ADMIN or API authority is required to call this API.
		         * @summary Predict SOD violations for identity.
		         * @param {IdentityWithNewAccessBeta} identityWithNewAccessBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @deprecated
		         * @throws {RequiredError}
		         */
		        startPredictSodViolations: function (identityWithNewAccessBeta, axiosOptions) {
		            return localVarFp.startPredictSodViolations(identityWithNewAccessBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.SODViolationsBetaApiFactory = SODViolationsBetaApiFactory;
		/**
		 * SODViolationsBetaApi - object-oriented interface
		 * @export
		 * @class SODViolationsBetaApi
		 * @extends {BaseAPI}
		 */
		var SODViolationsBetaApi = /** @class */ (function (_super) {
		    __extends(SODViolationsBetaApi, _super);
		    function SODViolationsBetaApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * This API is used to check if granting some additional accesses would cause the subject to be in violation of any SOD policies. Returns the violations that would be caused.  A token with ORG_ADMIN or API authority is required to call this API.
		     * @summary Predict SOD violations for identity.
		     * @param {SODViolationsBetaApiStartPredictSodViolationsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @deprecated
		     * @throws {RequiredError}
		     * @memberof SODViolationsBetaApi
		     */
		    SODViolationsBetaApi.prototype.startPredictSodViolations = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SODViolationsBetaApiFp)(this.configuration).startPredictSodViolations(requestParameters.identityWithNewAccessBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return SODViolationsBetaApi;
		}(base_1.BaseAPI));
		exports.SODViolationsBetaApi = SODViolationsBetaApi;
		/**
		 * SPConfigBetaApi - axios parameter creator
		 * @export
		 */
		var SPConfigBetaApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * This post will export objects from the tenant to a JSON configuration file. For more information about the object types that currently support export functionality, refer to [SaaS Configuration](https://developer.sailpoint.com/idn/docs/saas-configuration/#supported-objects).
		         * @summary Initiates configuration objects export job
		         * @param {ExportPayloadBeta} exportPayloadBeta Export options control what will be included in the export.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        exportSpConfig: function (exportPayloadBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'exportPayloadBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('exportSpConfig', 'exportPayloadBeta', exportPayloadBeta);
		                            localVarPath = "/sp-config/export";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(exportPayloadBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This endpoint gets the export file resulting from the export job with the requested `id` and downloads it to a file. The request will need one of the following security scopes: - sp:config:read - sp:config:manage
		         * @summary Download export job result.
		         * @param {string} id The ID of the export job whose results will be downloaded.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getSpConfigExport: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getSpConfigExport', 'id', id);
		                            localVarPath = "/sp-config/export/{id}/download"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets the status of the export job identified by the `id` parameter. The request will need one of the following security scopes: - sp:config:read - sp:config:manage
		         * @summary Get export job status
		         * @param {string} id The ID of the export job whose status will be returned.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getSpConfigExportStatus: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getSpConfigExportStatus', 'id', id);
		                            localVarPath = "/sp-config/export/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets import file resulting from the import job with the requested id and downloads it to a file. The downloaded file will contain the results of the import operation, including any error, warning or informational messages associated with the import. The request will need the following security scope: - sp:config:manage
		         * @summary Download import job result
		         * @param {string} id The ID of the import job whose results will be downloaded.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getSpConfigImport: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getSpConfigImport', 'id', id);
		                            localVarPath = "/sp-config/import/{id}/download"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets the status of the import job identified by the `id` parameter. For more information about the object types that currently support import functionality, refer to [SaaS Configuration](https://developer.sailpoint.com/idn/docs/saas-configuration/#supported-objects). The request will need the following security scope: - sp:config:manage
		         * @summary Get import job status
		         * @param {string} id The ID of the import job whose status will be returned.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getSpConfigImportStatus: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getSpConfigImportStatus', 'id', id);
		                            localVarPath = "/sp-config/import/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This post will import objects from a JSON configuration file into a tenant. By default, every import will first export all existing objects supported by sp-config as a backup before the import is attempted. The backup is provided so that the state of the configuration prior to the import is available for inspection or restore if needed. The backup can be skipped by setting \"excludeBackup\" to true in the import options. If a backup is performed, the id of the backup will be provided in the ImportResult as the \"exportJobId\". This can be downloaded  using the /sp-config/export/{exportJobId}/download endpoint. You cannot currently import from the Non-Employee Lifecycle Management (NELM) source. You cannot use this endpoint to back up or store NELM data.  For more information about the object types that currently support import functionality, refer to [SaaS Configuration](https://developer.sailpoint.com/idn/docs/saas-configuration/#supported-objects). The request will need the following security scope: - sp:config:manage
		         * @summary Initiates configuration objects import job
		         * @param {any} data JSON file containing the objects to be imported.
		         * @param {boolean} [preview] This option is intended to give the user information about how an import operation would proceed, without having any effect on the target tenant. If this parameter is \&quot;true\&quot;, no objects will be imported. Instead, the import process will pre-process the import file and attempt to resolve references within imported objects. The import result file will contain messages pertaining to how specific references were resolved, any errors associated with the preprocessing, and messages indicating which objects would be imported.
		         * @param {ImportOptionsBeta} [options]
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        importSpConfig: function (data, preview, options, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, localVarFormParams, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'data' is not null or undefined
		                            (0, common_1.assertParamExists)('importSpConfig', 'data', data);
		                            localVarPath = "/sp-config/import";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            localVarFormParams = new ((configuration && configuration.formDataCtor) || FormData)();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (preview !== undefined) {
		                                localVarQueryParameter['preview'] = preview;
		                            }
		                            if (data !== undefined) {
		                                localVarFormParams.append('data', data);
		                            }
		                            if (options !== undefined) {
		                                localVarFormParams.append('options', new Blob([JSON.stringify(options)], { type: "application/json", }));
		                            }
		                            localVarHeaderParameter['Content-Type'] = 'multipart/form-data';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = localVarFormParams;
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets the list of object configurations which are known to the tenant export/import service. Object configurations that contain \"importUrl\" and \"exportUrl\" are available for export/import.
		         * @summary Get config object details
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listSpConfigObjects: function (axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/sp-config/config-objects";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.SPConfigBetaApiAxiosParamCreator = SPConfigBetaApiAxiosParamCreator;
		/**
		 * SPConfigBetaApi - functional programming interface
		 * @export
		 */
		var SPConfigBetaApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.SPConfigBetaApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * This post will export objects from the tenant to a JSON configuration file. For more information about the object types that currently support export functionality, refer to [SaaS Configuration](https://developer.sailpoint.com/idn/docs/saas-configuration/#supported-objects).
		         * @summary Initiates configuration objects export job
		         * @param {ExportPayloadBeta} exportPayloadBeta Export options control what will be included in the export.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        exportSpConfig: function (exportPayloadBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.exportSpConfig(exportPayloadBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This endpoint gets the export file resulting from the export job with the requested `id` and downloads it to a file. The request will need one of the following security scopes: - sp:config:read - sp:config:manage
		         * @summary Download export job result.
		         * @param {string} id The ID of the export job whose results will be downloaded.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getSpConfigExport: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getSpConfigExport(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets the status of the export job identified by the `id` parameter. The request will need one of the following security scopes: - sp:config:read - sp:config:manage
		         * @summary Get export job status
		         * @param {string} id The ID of the export job whose status will be returned.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getSpConfigExportStatus: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getSpConfigExportStatus(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets import file resulting from the import job with the requested id and downloads it to a file. The downloaded file will contain the results of the import operation, including any error, warning or informational messages associated with the import. The request will need the following security scope: - sp:config:manage
		         * @summary Download import job result
		         * @param {string} id The ID of the import job whose results will be downloaded.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getSpConfigImport: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getSpConfigImport(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets the status of the import job identified by the `id` parameter. For more information about the object types that currently support import functionality, refer to [SaaS Configuration](https://developer.sailpoint.com/idn/docs/saas-configuration/#supported-objects). The request will need the following security scope: - sp:config:manage
		         * @summary Get import job status
		         * @param {string} id The ID of the import job whose status will be returned.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getSpConfigImportStatus: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getSpConfigImportStatus(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This post will import objects from a JSON configuration file into a tenant. By default, every import will first export all existing objects supported by sp-config as a backup before the import is attempted. The backup is provided so that the state of the configuration prior to the import is available for inspection or restore if needed. The backup can be skipped by setting \"excludeBackup\" to true in the import options. If a backup is performed, the id of the backup will be provided in the ImportResult as the \"exportJobId\". This can be downloaded  using the /sp-config/export/{exportJobId}/download endpoint. You cannot currently import from the Non-Employee Lifecycle Management (NELM) source. You cannot use this endpoint to back up or store NELM data.  For more information about the object types that currently support import functionality, refer to [SaaS Configuration](https://developer.sailpoint.com/idn/docs/saas-configuration/#supported-objects). The request will need the following security scope: - sp:config:manage
		         * @summary Initiates configuration objects import job
		         * @param {any} data JSON file containing the objects to be imported.
		         * @param {boolean} [preview] This option is intended to give the user information about how an import operation would proceed, without having any effect on the target tenant. If this parameter is \&quot;true\&quot;, no objects will be imported. Instead, the import process will pre-process the import file and attempt to resolve references within imported objects. The import result file will contain messages pertaining to how specific references were resolved, any errors associated with the preprocessing, and messages indicating which objects would be imported.
		         * @param {ImportOptionsBeta} [options]
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        importSpConfig: function (data, preview, options, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.importSpConfig(data, preview, options, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets the list of object configurations which are known to the tenant export/import service. Object configurations that contain \"importUrl\" and \"exportUrl\" are available for export/import.
		         * @summary Get config object details
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listSpConfigObjects: function (axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listSpConfigObjects(axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.SPConfigBetaApiFp = SPConfigBetaApiFp;
		/**
		 * SPConfigBetaApi - factory interface
		 * @export
		 */
		var SPConfigBetaApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.SPConfigBetaApiFp)(configuration);
		    return {
		        /**
		         * This post will export objects from the tenant to a JSON configuration file. For more information about the object types that currently support export functionality, refer to [SaaS Configuration](https://developer.sailpoint.com/idn/docs/saas-configuration/#supported-objects).
		         * @summary Initiates configuration objects export job
		         * @param {ExportPayloadBeta} exportPayloadBeta Export options control what will be included in the export.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        exportSpConfig: function (exportPayloadBeta, axiosOptions) {
		            return localVarFp.exportSpConfig(exportPayloadBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This endpoint gets the export file resulting from the export job with the requested `id` and downloads it to a file. The request will need one of the following security scopes: - sp:config:read - sp:config:manage
		         * @summary Download export job result.
		         * @param {string} id The ID of the export job whose results will be downloaded.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getSpConfigExport: function (id, axiosOptions) {
		            return localVarFp.getSpConfigExport(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This gets the status of the export job identified by the `id` parameter. The request will need one of the following security scopes: - sp:config:read - sp:config:manage
		         * @summary Get export job status
		         * @param {string} id The ID of the export job whose status will be returned.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getSpConfigExportStatus: function (id, axiosOptions) {
		            return localVarFp.getSpConfigExportStatus(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This gets import file resulting from the import job with the requested id and downloads it to a file. The downloaded file will contain the results of the import operation, including any error, warning or informational messages associated with the import. The request will need the following security scope: - sp:config:manage
		         * @summary Download import job result
		         * @param {string} id The ID of the import job whose results will be downloaded.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getSpConfigImport: function (id, axiosOptions) {
		            return localVarFp.getSpConfigImport(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This gets the status of the import job identified by the `id` parameter. For more information about the object types that currently support import functionality, refer to [SaaS Configuration](https://developer.sailpoint.com/idn/docs/saas-configuration/#supported-objects). The request will need the following security scope: - sp:config:manage
		         * @summary Get import job status
		         * @param {string} id The ID of the import job whose status will be returned.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getSpConfigImportStatus: function (id, axiosOptions) {
		            return localVarFp.getSpConfigImportStatus(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This post will import objects from a JSON configuration file into a tenant. By default, every import will first export all existing objects supported by sp-config as a backup before the import is attempted. The backup is provided so that the state of the configuration prior to the import is available for inspection or restore if needed. The backup can be skipped by setting \"excludeBackup\" to true in the import options. If a backup is performed, the id of the backup will be provided in the ImportResult as the \"exportJobId\". This can be downloaded  using the /sp-config/export/{exportJobId}/download endpoint. You cannot currently import from the Non-Employee Lifecycle Management (NELM) source. You cannot use this endpoint to back up or store NELM data.  For more information about the object types that currently support import functionality, refer to [SaaS Configuration](https://developer.sailpoint.com/idn/docs/saas-configuration/#supported-objects). The request will need the following security scope: - sp:config:manage
		         * @summary Initiates configuration objects import job
		         * @param {any} data JSON file containing the objects to be imported.
		         * @param {boolean} [preview] This option is intended to give the user information about how an import operation would proceed, without having any effect on the target tenant. If this parameter is \&quot;true\&quot;, no objects will be imported. Instead, the import process will pre-process the import file and attempt to resolve references within imported objects. The import result file will contain messages pertaining to how specific references were resolved, any errors associated with the preprocessing, and messages indicating which objects would be imported.
		         * @param {ImportOptionsBeta} [options]
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        importSpConfig: function (data, preview, options, axiosOptions) {
		            return localVarFp.importSpConfig(data, preview, options, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This gets the list of object configurations which are known to the tenant export/import service. Object configurations that contain \"importUrl\" and \"exportUrl\" are available for export/import.
		         * @summary Get config object details
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listSpConfigObjects: function (axiosOptions) {
		            return localVarFp.listSpConfigObjects(axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.SPConfigBetaApiFactory = SPConfigBetaApiFactory;
		/**
		 * SPConfigBetaApi - object-oriented interface
		 * @export
		 * @class SPConfigBetaApi
		 * @extends {BaseAPI}
		 */
		var SPConfigBetaApi = /** @class */ (function (_super) {
		    __extends(SPConfigBetaApi, _super);
		    function SPConfigBetaApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * This post will export objects from the tenant to a JSON configuration file. For more information about the object types that currently support export functionality, refer to [SaaS Configuration](https://developer.sailpoint.com/idn/docs/saas-configuration/#supported-objects).
		     * @summary Initiates configuration objects export job
		     * @param {SPConfigBetaApiExportSpConfigRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SPConfigBetaApi
		     */
		    SPConfigBetaApi.prototype.exportSpConfig = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SPConfigBetaApiFp)(this.configuration).exportSpConfig(requestParameters.exportPayloadBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This endpoint gets the export file resulting from the export job with the requested `id` and downloads it to a file. The request will need one of the following security scopes: - sp:config:read - sp:config:manage
		     * @summary Download export job result.
		     * @param {SPConfigBetaApiGetSpConfigExportRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SPConfigBetaApi
		     */
		    SPConfigBetaApi.prototype.getSpConfigExport = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SPConfigBetaApiFp)(this.configuration).getSpConfigExport(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This gets the status of the export job identified by the `id` parameter. The request will need one of the following security scopes: - sp:config:read - sp:config:manage
		     * @summary Get export job status
		     * @param {SPConfigBetaApiGetSpConfigExportStatusRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SPConfigBetaApi
		     */
		    SPConfigBetaApi.prototype.getSpConfigExportStatus = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SPConfigBetaApiFp)(this.configuration).getSpConfigExportStatus(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This gets import file resulting from the import job with the requested id and downloads it to a file. The downloaded file will contain the results of the import operation, including any error, warning or informational messages associated with the import. The request will need the following security scope: - sp:config:manage
		     * @summary Download import job result
		     * @param {SPConfigBetaApiGetSpConfigImportRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SPConfigBetaApi
		     */
		    SPConfigBetaApi.prototype.getSpConfigImport = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SPConfigBetaApiFp)(this.configuration).getSpConfigImport(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This gets the status of the import job identified by the `id` parameter. For more information about the object types that currently support import functionality, refer to [SaaS Configuration](https://developer.sailpoint.com/idn/docs/saas-configuration/#supported-objects). The request will need the following security scope: - sp:config:manage
		     * @summary Get import job status
		     * @param {SPConfigBetaApiGetSpConfigImportStatusRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SPConfigBetaApi
		     */
		    SPConfigBetaApi.prototype.getSpConfigImportStatus = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SPConfigBetaApiFp)(this.configuration).getSpConfigImportStatus(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This post will import objects from a JSON configuration file into a tenant. By default, every import will first export all existing objects supported by sp-config as a backup before the import is attempted. The backup is provided so that the state of the configuration prior to the import is available for inspection or restore if needed. The backup can be skipped by setting \"excludeBackup\" to true in the import options. If a backup is performed, the id of the backup will be provided in the ImportResult as the \"exportJobId\". This can be downloaded  using the /sp-config/export/{exportJobId}/download endpoint. You cannot currently import from the Non-Employee Lifecycle Management (NELM) source. You cannot use this endpoint to back up or store NELM data.  For more information about the object types that currently support import functionality, refer to [SaaS Configuration](https://developer.sailpoint.com/idn/docs/saas-configuration/#supported-objects). The request will need the following security scope: - sp:config:manage
		     * @summary Initiates configuration objects import job
		     * @param {SPConfigBetaApiImportSpConfigRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SPConfigBetaApi
		     */
		    SPConfigBetaApi.prototype.importSpConfig = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SPConfigBetaApiFp)(this.configuration).importSpConfig(requestParameters.data, requestParameters.preview, requestParameters.options, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This gets the list of object configurations which are known to the tenant export/import service. Object configurations that contain \"importUrl\" and \"exportUrl\" are available for export/import.
		     * @summary Get config object details
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SPConfigBetaApi
		     */
		    SPConfigBetaApi.prototype.listSpConfigObjects = function (axiosOptions) {
		        var _this = this;
		        return (0, exports.SPConfigBetaApiFp)(this.configuration).listSpConfigObjects(axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return SPConfigBetaApi;
		}(base_1.BaseAPI));
		exports.SPConfigBetaApi = SPConfigBetaApi;
		/**
		 * SearchAttributeConfigurationBetaApi - axios parameter creator
		 * @export
		 */
		var SearchAttributeConfigurationBetaApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * This API accepts an attribute name, an attribute display name and a list of name/value pair associates of application IDs to attribute names.  It will then validate the inputs and configure/create and attribute promotion configuration in the Link ObjectConfig. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Configure/create extended search attributes in IdentityNow.
		         * @param {SearchAttributeConfigBeta} searchAttributeConfigBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createSearchAttributeConfig: function (searchAttributeConfigBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'searchAttributeConfigBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('createSearchAttributeConfig', 'searchAttributeConfigBeta', searchAttributeConfigBeta);
		                            localVarPath = "/accounts/search-attribute-config";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(searchAttributeConfigBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API accepts an extended attribute name and deletes the corresponding extended attribute configuration. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Delete an extended search attribute in IdentityNow.
		         * @param {string} name Name of the extended search attribute configuration to delete.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteSearchAttributeConfig: function (name, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'name' is not null or undefined
		                            (0, common_1.assertParamExists)('deleteSearchAttributeConfig', 'name', name);
		                            localVarPath = "/accounts/search-attribute-config/{name}"
		                                .replace("{".concat("name", "}"), encodeURIComponent(String(name)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'DELETE' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API retrieves a list of attribute/application associates currently configured in IdentityNow. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Retrieve a list of extended search attributes in IdentityNow.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getSearchAttributeConfig: function (axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/accounts/search-attribute-config";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API accepts an extended attribute name and retrieves the corresponding extended attribute configuration. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Get the details of a specific extended search attribute in IdentityNow.
		         * @param {string} name Name of the extended search attribute configuration to delete.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getSingleSearchAttributeConfig: function (name, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'name' is not null or undefined
		                            (0, common_1.assertParamExists)('getSingleSearchAttributeConfig', 'name', name);
		                            localVarPath = "/accounts/search-attribute-config/{name}"
		                                .replace("{".concat("name", "}"), encodeURIComponent(String(name)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API updates an existing Search Attribute Configuration. The following fields are patchable: **name**, **displayName**, **applicationAttributes** A token with ORG_ADMIN authority is required to call this API.
		         * @summary Update the details of a specific extended search attribute in IdentityNow.
		         * @param {string} name Name of the Search Attribute Configuration to patch.
		         * @param {Array<JsonPatchOperationBeta>} jsonPatchOperationBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchSearchAttributeConfig: function (name, jsonPatchOperationBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'name' is not null or undefined
		                            (0, common_1.assertParamExists)('patchSearchAttributeConfig', 'name', name);
		                            // verify required parameter 'jsonPatchOperationBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('patchSearchAttributeConfig', 'jsonPatchOperationBeta', jsonPatchOperationBeta);
		                            localVarPath = "/accounts/search-attribute-config/{name}"
		                                .replace("{".concat("name", "}"), encodeURIComponent(String(name)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PATCH' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json-patch+json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(jsonPatchOperationBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.SearchAttributeConfigurationBetaApiAxiosParamCreator = SearchAttributeConfigurationBetaApiAxiosParamCreator;
		/**
		 * SearchAttributeConfigurationBetaApi - functional programming interface
		 * @export
		 */
		var SearchAttributeConfigurationBetaApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.SearchAttributeConfigurationBetaApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * This API accepts an attribute name, an attribute display name and a list of name/value pair associates of application IDs to attribute names.  It will then validate the inputs and configure/create and attribute promotion configuration in the Link ObjectConfig. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Configure/create extended search attributes in IdentityNow.
		         * @param {SearchAttributeConfigBeta} searchAttributeConfigBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createSearchAttributeConfig: function (searchAttributeConfigBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.createSearchAttributeConfig(searchAttributeConfigBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API accepts an extended attribute name and deletes the corresponding extended attribute configuration. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Delete an extended search attribute in IdentityNow.
		         * @param {string} name Name of the extended search attribute configuration to delete.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteSearchAttributeConfig: function (name, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.deleteSearchAttributeConfig(name, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API retrieves a list of attribute/application associates currently configured in IdentityNow. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Retrieve a list of extended search attributes in IdentityNow.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getSearchAttributeConfig: function (axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getSearchAttributeConfig(axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API accepts an extended attribute name and retrieves the corresponding extended attribute configuration. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Get the details of a specific extended search attribute in IdentityNow.
		         * @param {string} name Name of the extended search attribute configuration to delete.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getSingleSearchAttributeConfig: function (name, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getSingleSearchAttributeConfig(name, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API updates an existing Search Attribute Configuration. The following fields are patchable: **name**, **displayName**, **applicationAttributes** A token with ORG_ADMIN authority is required to call this API.
		         * @summary Update the details of a specific extended search attribute in IdentityNow.
		         * @param {string} name Name of the Search Attribute Configuration to patch.
		         * @param {Array<JsonPatchOperationBeta>} jsonPatchOperationBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchSearchAttributeConfig: function (name, jsonPatchOperationBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.patchSearchAttributeConfig(name, jsonPatchOperationBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.SearchAttributeConfigurationBetaApiFp = SearchAttributeConfigurationBetaApiFp;
		/**
		 * SearchAttributeConfigurationBetaApi - factory interface
		 * @export
		 */
		var SearchAttributeConfigurationBetaApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.SearchAttributeConfigurationBetaApiFp)(configuration);
		    return {
		        /**
		         * This API accepts an attribute name, an attribute display name and a list of name/value pair associates of application IDs to attribute names.  It will then validate the inputs and configure/create and attribute promotion configuration in the Link ObjectConfig. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Configure/create extended search attributes in IdentityNow.
		         * @param {SearchAttributeConfigBeta} searchAttributeConfigBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createSearchAttributeConfig: function (searchAttributeConfigBeta, axiosOptions) {
		            return localVarFp.createSearchAttributeConfig(searchAttributeConfigBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API accepts an extended attribute name and deletes the corresponding extended attribute configuration. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Delete an extended search attribute in IdentityNow.
		         * @param {string} name Name of the extended search attribute configuration to delete.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteSearchAttributeConfig: function (name, axiosOptions) {
		            return localVarFp.deleteSearchAttributeConfig(name, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API retrieves a list of attribute/application associates currently configured in IdentityNow. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Retrieve a list of extended search attributes in IdentityNow.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getSearchAttributeConfig: function (axiosOptions) {
		            return localVarFp.getSearchAttributeConfig(axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API accepts an extended attribute name and retrieves the corresponding extended attribute configuration. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Get the details of a specific extended search attribute in IdentityNow.
		         * @param {string} name Name of the extended search attribute configuration to delete.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getSingleSearchAttributeConfig: function (name, axiosOptions) {
		            return localVarFp.getSingleSearchAttributeConfig(name, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API updates an existing Search Attribute Configuration. The following fields are patchable: **name**, **displayName**, **applicationAttributes** A token with ORG_ADMIN authority is required to call this API.
		         * @summary Update the details of a specific extended search attribute in IdentityNow.
		         * @param {string} name Name of the Search Attribute Configuration to patch.
		         * @param {Array<JsonPatchOperationBeta>} jsonPatchOperationBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchSearchAttributeConfig: function (name, jsonPatchOperationBeta, axiosOptions) {
		            return localVarFp.patchSearchAttributeConfig(name, jsonPatchOperationBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.SearchAttributeConfigurationBetaApiFactory = SearchAttributeConfigurationBetaApiFactory;
		/**
		 * SearchAttributeConfigurationBetaApi - object-oriented interface
		 * @export
		 * @class SearchAttributeConfigurationBetaApi
		 * @extends {BaseAPI}
		 */
		var SearchAttributeConfigurationBetaApi = /** @class */ (function (_super) {
		    __extends(SearchAttributeConfigurationBetaApi, _super);
		    function SearchAttributeConfigurationBetaApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * This API accepts an attribute name, an attribute display name and a list of name/value pair associates of application IDs to attribute names.  It will then validate the inputs and configure/create and attribute promotion configuration in the Link ObjectConfig. A token with ORG_ADMIN authority is required to call this API.
		     * @summary Configure/create extended search attributes in IdentityNow.
		     * @param {SearchAttributeConfigurationBetaApiCreateSearchAttributeConfigRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SearchAttributeConfigurationBetaApi
		     */
		    SearchAttributeConfigurationBetaApi.prototype.createSearchAttributeConfig = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SearchAttributeConfigurationBetaApiFp)(this.configuration).createSearchAttributeConfig(requestParameters.searchAttributeConfigBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API accepts an extended attribute name and deletes the corresponding extended attribute configuration. A token with ORG_ADMIN authority is required to call this API.
		     * @summary Delete an extended search attribute in IdentityNow.
		     * @param {SearchAttributeConfigurationBetaApiDeleteSearchAttributeConfigRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SearchAttributeConfigurationBetaApi
		     */
		    SearchAttributeConfigurationBetaApi.prototype.deleteSearchAttributeConfig = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SearchAttributeConfigurationBetaApiFp)(this.configuration).deleteSearchAttributeConfig(requestParameters.name, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API retrieves a list of attribute/application associates currently configured in IdentityNow. A token with ORG_ADMIN authority is required to call this API.
		     * @summary Retrieve a list of extended search attributes in IdentityNow.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SearchAttributeConfigurationBetaApi
		     */
		    SearchAttributeConfigurationBetaApi.prototype.getSearchAttributeConfig = function (axiosOptions) {
		        var _this = this;
		        return (0, exports.SearchAttributeConfigurationBetaApiFp)(this.configuration).getSearchAttributeConfig(axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API accepts an extended attribute name and retrieves the corresponding extended attribute configuration. A token with ORG_ADMIN authority is required to call this API.
		     * @summary Get the details of a specific extended search attribute in IdentityNow.
		     * @param {SearchAttributeConfigurationBetaApiGetSingleSearchAttributeConfigRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SearchAttributeConfigurationBetaApi
		     */
		    SearchAttributeConfigurationBetaApi.prototype.getSingleSearchAttributeConfig = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SearchAttributeConfigurationBetaApiFp)(this.configuration).getSingleSearchAttributeConfig(requestParameters.name, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API updates an existing Search Attribute Configuration. The following fields are patchable: **name**, **displayName**, **applicationAttributes** A token with ORG_ADMIN authority is required to call this API.
		     * @summary Update the details of a specific extended search attribute in IdentityNow.
		     * @param {SearchAttributeConfigurationBetaApiPatchSearchAttributeConfigRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SearchAttributeConfigurationBetaApi
		     */
		    SearchAttributeConfigurationBetaApi.prototype.patchSearchAttributeConfig = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SearchAttributeConfigurationBetaApiFp)(this.configuration).patchSearchAttributeConfig(requestParameters.name, requestParameters.jsonPatchOperationBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return SearchAttributeConfigurationBetaApi;
		}(base_1.BaseAPI));
		exports.SearchAttributeConfigurationBetaApi = SearchAttributeConfigurationBetaApi;
		/**
		 * SegmentsBetaApi - axios parameter creator
		 * @export
		 */
		var SegmentsBetaApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * This API creates a segment.  >**Note:** Segment definitions may take time to propagate to all identities. A token with ORG_ADMIN or API authority is required to call this API.
		         * @summary Create Segment
		         * @param {SegmentBeta} segmentBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createSegment: function (segmentBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'segmentBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('createSegment', 'segmentBeta', segmentBeta);
		                            localVarPath = "/segments";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(segmentBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API deletes the segment specified by the given ID. >**Note:** Segment deletion may take some time to go into effect.  A token with ORG_ADMIN or API authority is required to call this API.
		         * @summary Delete Segment by ID
		         * @param {string} id The segment ID to delete.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteSegment: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('deleteSegment', 'id', id);
		                            localVarPath = "/segments/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'DELETE' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns the segment specified by the given ID. A token with ORG_ADMIN or API authority is required to call this API.
		         * @summary Get Segment by ID
		         * @param {string} id The segment ID to retrieve.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getSegment: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getSegment', 'id', id);
		                            localVarPath = "/segments/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns a list of all segments. A token with ORG_ADMIN or API authority is required to call this API.
		         * @summary List Segments
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listSegments: function (limit, offset, count, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/segments";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Use this API to update segment fields by using the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard. >**Note:** Changes to a segment may take some time to propagate to all identities. A token with ORG_ADMIN or API authority is required to call this API.
		         * @summary Update Segment
		         * @param {string} id The segment ID to modify.
		         * @param {Array<object>} requestBody A list of segment update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.  The following fields are patchable: * name * description * owner * visibilityCriteria * active
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchSegment: function (id, requestBody, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('patchSegment', 'id', id);
		                            // verify required parameter 'requestBody' is not null or undefined
		                            (0, common_1.assertParamExists)('patchSegment', 'requestBody', requestBody);
		                            localVarPath = "/segments/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PATCH' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json-patch+json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(requestBody, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.SegmentsBetaApiAxiosParamCreator = SegmentsBetaApiAxiosParamCreator;
		/**
		 * SegmentsBetaApi - functional programming interface
		 * @export
		 */
		var SegmentsBetaApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.SegmentsBetaApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * This API creates a segment.  >**Note:** Segment definitions may take time to propagate to all identities. A token with ORG_ADMIN or API authority is required to call this API.
		         * @summary Create Segment
		         * @param {SegmentBeta} segmentBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createSegment: function (segmentBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.createSegment(segmentBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API deletes the segment specified by the given ID. >**Note:** Segment deletion may take some time to go into effect.  A token with ORG_ADMIN or API authority is required to call this API.
		         * @summary Delete Segment by ID
		         * @param {string} id The segment ID to delete.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteSegment: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.deleteSegment(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns the segment specified by the given ID. A token with ORG_ADMIN or API authority is required to call this API.
		         * @summary Get Segment by ID
		         * @param {string} id The segment ID to retrieve.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getSegment: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getSegment(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns a list of all segments. A token with ORG_ADMIN or API authority is required to call this API.
		         * @summary List Segments
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listSegments: function (limit, offset, count, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listSegments(limit, offset, count, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Use this API to update segment fields by using the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard. >**Note:** Changes to a segment may take some time to propagate to all identities. A token with ORG_ADMIN or API authority is required to call this API.
		         * @summary Update Segment
		         * @param {string} id The segment ID to modify.
		         * @param {Array<object>} requestBody A list of segment update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.  The following fields are patchable: * name * description * owner * visibilityCriteria * active
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchSegment: function (id, requestBody, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.patchSegment(id, requestBody, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.SegmentsBetaApiFp = SegmentsBetaApiFp;
		/**
		 * SegmentsBetaApi - factory interface
		 * @export
		 */
		var SegmentsBetaApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.SegmentsBetaApiFp)(configuration);
		    return {
		        /**
		         * This API creates a segment.  >**Note:** Segment definitions may take time to propagate to all identities. A token with ORG_ADMIN or API authority is required to call this API.
		         * @summary Create Segment
		         * @param {SegmentBeta} segmentBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createSegment: function (segmentBeta, axiosOptions) {
		            return localVarFp.createSegment(segmentBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API deletes the segment specified by the given ID. >**Note:** Segment deletion may take some time to go into effect.  A token with ORG_ADMIN or API authority is required to call this API.
		         * @summary Delete Segment by ID
		         * @param {string} id The segment ID to delete.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteSegment: function (id, axiosOptions) {
		            return localVarFp.deleteSegment(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API returns the segment specified by the given ID. A token with ORG_ADMIN or API authority is required to call this API.
		         * @summary Get Segment by ID
		         * @param {string} id The segment ID to retrieve.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getSegment: function (id, axiosOptions) {
		            return localVarFp.getSegment(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API returns a list of all segments. A token with ORG_ADMIN or API authority is required to call this API.
		         * @summary List Segments
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listSegments: function (limit, offset, count, axiosOptions) {
		            return localVarFp.listSegments(limit, offset, count, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Use this API to update segment fields by using the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard. >**Note:** Changes to a segment may take some time to propagate to all identities. A token with ORG_ADMIN or API authority is required to call this API.
		         * @summary Update Segment
		         * @param {string} id The segment ID to modify.
		         * @param {Array<object>} requestBody A list of segment update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.  The following fields are patchable: * name * description * owner * visibilityCriteria * active
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchSegment: function (id, requestBody, axiosOptions) {
		            return localVarFp.patchSegment(id, requestBody, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.SegmentsBetaApiFactory = SegmentsBetaApiFactory;
		/**
		 * SegmentsBetaApi - object-oriented interface
		 * @export
		 * @class SegmentsBetaApi
		 * @extends {BaseAPI}
		 */
		var SegmentsBetaApi = /** @class */ (function (_super) {
		    __extends(SegmentsBetaApi, _super);
		    function SegmentsBetaApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * This API creates a segment.  >**Note:** Segment definitions may take time to propagate to all identities. A token with ORG_ADMIN or API authority is required to call this API.
		     * @summary Create Segment
		     * @param {SegmentsBetaApiCreateSegmentRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SegmentsBetaApi
		     */
		    SegmentsBetaApi.prototype.createSegment = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SegmentsBetaApiFp)(this.configuration).createSegment(requestParameters.segmentBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API deletes the segment specified by the given ID. >**Note:** Segment deletion may take some time to go into effect.  A token with ORG_ADMIN or API authority is required to call this API.
		     * @summary Delete Segment by ID
		     * @param {SegmentsBetaApiDeleteSegmentRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SegmentsBetaApi
		     */
		    SegmentsBetaApi.prototype.deleteSegment = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SegmentsBetaApiFp)(this.configuration).deleteSegment(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API returns the segment specified by the given ID. A token with ORG_ADMIN or API authority is required to call this API.
		     * @summary Get Segment by ID
		     * @param {SegmentsBetaApiGetSegmentRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SegmentsBetaApi
		     */
		    SegmentsBetaApi.prototype.getSegment = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SegmentsBetaApiFp)(this.configuration).getSegment(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API returns a list of all segments. A token with ORG_ADMIN or API authority is required to call this API.
		     * @summary List Segments
		     * @param {SegmentsBetaApiListSegmentsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SegmentsBetaApi
		     */
		    SegmentsBetaApi.prototype.listSegments = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.SegmentsBetaApiFp)(this.configuration).listSegments(requestParameters.limit, requestParameters.offset, requestParameters.count, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Use this API to update segment fields by using the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard. >**Note:** Changes to a segment may take some time to propagate to all identities. A token with ORG_ADMIN or API authority is required to call this API.
		     * @summary Update Segment
		     * @param {SegmentsBetaApiPatchSegmentRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SegmentsBetaApi
		     */
		    SegmentsBetaApi.prototype.patchSegment = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SegmentsBetaApiFp)(this.configuration).patchSegment(requestParameters.id, requestParameters.requestBody, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return SegmentsBetaApi;
		}(base_1.BaseAPI));
		exports.SegmentsBetaApi = SegmentsBetaApi;
		/**
		 * ServiceDeskIntegrationBetaApi - axios parameter creator
		 * @export
		 */
		var ServiceDeskIntegrationBetaApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * Create a new Service Desk Integrations.  A token with Org Admin or Service Desk Admin authority is required to access this endpoint.
		         * @summary Create new Service Desk integration
		         * @param {ServiceDeskIntegrationDtoBeta} serviceDeskIntegrationDtoBeta The specifics of a new integration to create
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createServiceDeskIntegration: function (serviceDeskIntegrationDtoBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'serviceDeskIntegrationDtoBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('createServiceDeskIntegration', 'serviceDeskIntegrationDtoBeta', serviceDeskIntegrationDtoBeta);
		                            localVarPath = "/service-desk-integrations";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(serviceDeskIntegrationDtoBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Delete an existing Service Desk integration by ID.  A token with Org Admin or Service Desk Admin authority is required to access this endpoint.
		         * @summary Delete a Service Desk integration
		         * @param {string} id ID of Service Desk integration to delete
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteServiceDeskIntegration: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('deleteServiceDeskIntegration', 'id', id);
		                            localVarPath = "/service-desk-integrations/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'DELETE' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Get an existing Service Desk integration by ID.  A token with Org Admin or Service Desk Admin authority is required to access this endpoint.
		         * @summary Get a Service Desk integration
		         * @param {string} id ID of the Service Desk integration to get
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getServiceDeskIntegration: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getServiceDeskIntegration', 'id', id);
		                            localVarPath = "/service-desk-integrations/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Get a list of ServiceDeskIntegrationDto for existing Service Desk Integrations.  A token with Org Admin or Service Desk Admin authority is required to access this endpoint.
		         * @summary List existing Service Desk Integrations
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name**
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **name**: *eq*  **type**: *eq, in*  **cluster**: *eq, in*
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getServiceDeskIntegrationList: function (offset, limit, sorters, filters, count, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/service-desk-integrations";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API endpoint returns an existing Service Desk integration template by scriptName.  A token with Org Admin or Service Desk Admin authority is required to access this endpoint.
		         * @summary Service Desk integration template by scriptName.
		         * @param {string} scriptName The scriptName value of the Service Desk integration template to get
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getServiceDeskIntegrationTemplate: function (scriptName, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'scriptName' is not null or undefined
		                            (0, common_1.assertParamExists)('getServiceDeskIntegrationTemplate', 'scriptName', scriptName);
		                            localVarPath = "/service-desk-integrations/templates/{scriptName}"
		                                .replace("{".concat("scriptName", "}"), encodeURIComponent(String(scriptName)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API endpoint returns the current list of supported Service Desk integration types.  A token with Org Admin or Service Desk Admin authority is required to access this endpoint.
		         * @summary Service Desk Integration Types List.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getServiceDeskIntegrationTypes: function (axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/service-desk-integrations/types";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Get the time check configuration of queued SDIM tickets.  A token with Org Admin or Service Desk Admin authority is required to access this endpoint.
		         * @summary Get the time check configuration
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getStatusCheckDetails: function (axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/service-desk-integrations/status-check-configuration";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Update an existing ServiceDeskIntegration by ID with a PATCH request.
		         * @summary Service Desk Integration Update PATCH
		         * @param {string} id ID of the Service Desk integration to update
		         * @param {PatchServiceDeskIntegrationRequestBeta} patchServiceDeskIntegrationRequestBeta A list of SDIM update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.  Only &#x60;replace&#x60; operations are accepted by this endpoint.  A 403 Forbidden Error indicates that you attempted to PATCH a operation that is not allowed.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchServiceDeskIntegration: function (id, patchServiceDeskIntegrationRequestBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('patchServiceDeskIntegration', 'id', id);
		                            // verify required parameter 'patchServiceDeskIntegrationRequestBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('patchServiceDeskIntegration', 'patchServiceDeskIntegrationRequestBeta', patchServiceDeskIntegrationRequestBeta);
		                            localVarPath = "/service-desk-integrations/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PATCH' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json-patch+json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(patchServiceDeskIntegrationRequestBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Update an existing Service Desk integration by ID with updated value in JSON form as the request body.  A token with Org Admin or Service Desk Admin authority is required to access this endpoint.
		         * @summary Update a Service Desk integration
		         * @param {string} id ID of the Service Desk integration to update
		         * @param {ServiceDeskIntegrationDtoBeta} serviceDeskIntegrationDtoBeta The specifics of the integration to update
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putServiceDeskIntegration: function (id, serviceDeskIntegrationDtoBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('putServiceDeskIntegration', 'id', id);
		                            // verify required parameter 'serviceDeskIntegrationDtoBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('putServiceDeskIntegration', 'serviceDeskIntegrationDtoBeta', serviceDeskIntegrationDtoBeta);
		                            localVarPath = "/service-desk-integrations/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PUT' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(serviceDeskIntegrationDtoBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Update the time check configuration of queued SDIM tickets.  A token with Org Admin or Service Desk Admin authority is required to access this endpoint.
		         * @summary Update the time check configuration
		         * @param {QueuedCheckConfigDetailsBeta} queuedCheckConfigDetailsBeta the modified time check configuration
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateStatusCheckDetails: function (queuedCheckConfigDetailsBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'queuedCheckConfigDetailsBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('updateStatusCheckDetails', 'queuedCheckConfigDetailsBeta', queuedCheckConfigDetailsBeta);
		                            localVarPath = "/service-desk-integrations/status-check-configuration";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PUT' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(queuedCheckConfigDetailsBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.ServiceDeskIntegrationBetaApiAxiosParamCreator = ServiceDeskIntegrationBetaApiAxiosParamCreator;
		/**
		 * ServiceDeskIntegrationBetaApi - functional programming interface
		 * @export
		 */
		var ServiceDeskIntegrationBetaApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.ServiceDeskIntegrationBetaApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * Create a new Service Desk Integrations.  A token with Org Admin or Service Desk Admin authority is required to access this endpoint.
		         * @summary Create new Service Desk integration
		         * @param {ServiceDeskIntegrationDtoBeta} serviceDeskIntegrationDtoBeta The specifics of a new integration to create
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createServiceDeskIntegration: function (serviceDeskIntegrationDtoBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.createServiceDeskIntegration(serviceDeskIntegrationDtoBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Delete an existing Service Desk integration by ID.  A token with Org Admin or Service Desk Admin authority is required to access this endpoint.
		         * @summary Delete a Service Desk integration
		         * @param {string} id ID of Service Desk integration to delete
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteServiceDeskIntegration: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.deleteServiceDeskIntegration(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Get an existing Service Desk integration by ID.  A token with Org Admin or Service Desk Admin authority is required to access this endpoint.
		         * @summary Get a Service Desk integration
		         * @param {string} id ID of the Service Desk integration to get
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getServiceDeskIntegration: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getServiceDeskIntegration(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Get a list of ServiceDeskIntegrationDto for existing Service Desk Integrations.  A token with Org Admin or Service Desk Admin authority is required to access this endpoint.
		         * @summary List existing Service Desk Integrations
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name**
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **name**: *eq*  **type**: *eq, in*  **cluster**: *eq, in*
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getServiceDeskIntegrationList: function (offset, limit, sorters, filters, count, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getServiceDeskIntegrationList(offset, limit, sorters, filters, count, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API endpoint returns an existing Service Desk integration template by scriptName.  A token with Org Admin or Service Desk Admin authority is required to access this endpoint.
		         * @summary Service Desk integration template by scriptName.
		         * @param {string} scriptName The scriptName value of the Service Desk integration template to get
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getServiceDeskIntegrationTemplate: function (scriptName, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getServiceDeskIntegrationTemplate(scriptName, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API endpoint returns the current list of supported Service Desk integration types.  A token with Org Admin or Service Desk Admin authority is required to access this endpoint.
		         * @summary Service Desk Integration Types List.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getServiceDeskIntegrationTypes: function (axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getServiceDeskIntegrationTypes(axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Get the time check configuration of queued SDIM tickets.  A token with Org Admin or Service Desk Admin authority is required to access this endpoint.
		         * @summary Get the time check configuration
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getStatusCheckDetails: function (axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getStatusCheckDetails(axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Update an existing ServiceDeskIntegration by ID with a PATCH request.
		         * @summary Service Desk Integration Update PATCH
		         * @param {string} id ID of the Service Desk integration to update
		         * @param {PatchServiceDeskIntegrationRequestBeta} patchServiceDeskIntegrationRequestBeta A list of SDIM update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.  Only &#x60;replace&#x60; operations are accepted by this endpoint.  A 403 Forbidden Error indicates that you attempted to PATCH a operation that is not allowed.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchServiceDeskIntegration: function (id, patchServiceDeskIntegrationRequestBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.patchServiceDeskIntegration(id, patchServiceDeskIntegrationRequestBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Update an existing Service Desk integration by ID with updated value in JSON form as the request body.  A token with Org Admin or Service Desk Admin authority is required to access this endpoint.
		         * @summary Update a Service Desk integration
		         * @param {string} id ID of the Service Desk integration to update
		         * @param {ServiceDeskIntegrationDtoBeta} serviceDeskIntegrationDtoBeta The specifics of the integration to update
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putServiceDeskIntegration: function (id, serviceDeskIntegrationDtoBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.putServiceDeskIntegration(id, serviceDeskIntegrationDtoBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Update the time check configuration of queued SDIM tickets.  A token with Org Admin or Service Desk Admin authority is required to access this endpoint.
		         * @summary Update the time check configuration
		         * @param {QueuedCheckConfigDetailsBeta} queuedCheckConfigDetailsBeta the modified time check configuration
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateStatusCheckDetails: function (queuedCheckConfigDetailsBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.updateStatusCheckDetails(queuedCheckConfigDetailsBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.ServiceDeskIntegrationBetaApiFp = ServiceDeskIntegrationBetaApiFp;
		/**
		 * ServiceDeskIntegrationBetaApi - factory interface
		 * @export
		 */
		var ServiceDeskIntegrationBetaApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.ServiceDeskIntegrationBetaApiFp)(configuration);
		    return {
		        /**
		         * Create a new Service Desk Integrations.  A token with Org Admin or Service Desk Admin authority is required to access this endpoint.
		         * @summary Create new Service Desk integration
		         * @param {ServiceDeskIntegrationDtoBeta} serviceDeskIntegrationDtoBeta The specifics of a new integration to create
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createServiceDeskIntegration: function (serviceDeskIntegrationDtoBeta, axiosOptions) {
		            return localVarFp.createServiceDeskIntegration(serviceDeskIntegrationDtoBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Delete an existing Service Desk integration by ID.  A token with Org Admin or Service Desk Admin authority is required to access this endpoint.
		         * @summary Delete a Service Desk integration
		         * @param {string} id ID of Service Desk integration to delete
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteServiceDeskIntegration: function (id, axiosOptions) {
		            return localVarFp.deleteServiceDeskIntegration(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Get an existing Service Desk integration by ID.  A token with Org Admin or Service Desk Admin authority is required to access this endpoint.
		         * @summary Get a Service Desk integration
		         * @param {string} id ID of the Service Desk integration to get
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getServiceDeskIntegration: function (id, axiosOptions) {
		            return localVarFp.getServiceDeskIntegration(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Get a list of ServiceDeskIntegrationDto for existing Service Desk Integrations.  A token with Org Admin or Service Desk Admin authority is required to access this endpoint.
		         * @summary List existing Service Desk Integrations
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name**
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **name**: *eq*  **type**: *eq, in*  **cluster**: *eq, in*
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getServiceDeskIntegrationList: function (offset, limit, sorters, filters, count, axiosOptions) {
		            return localVarFp.getServiceDeskIntegrationList(offset, limit, sorters, filters, count, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API endpoint returns an existing Service Desk integration template by scriptName.  A token with Org Admin or Service Desk Admin authority is required to access this endpoint.
		         * @summary Service Desk integration template by scriptName.
		         * @param {string} scriptName The scriptName value of the Service Desk integration template to get
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getServiceDeskIntegrationTemplate: function (scriptName, axiosOptions) {
		            return localVarFp.getServiceDeskIntegrationTemplate(scriptName, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API endpoint returns the current list of supported Service Desk integration types.  A token with Org Admin or Service Desk Admin authority is required to access this endpoint.
		         * @summary Service Desk Integration Types List.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getServiceDeskIntegrationTypes: function (axiosOptions) {
		            return localVarFp.getServiceDeskIntegrationTypes(axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Get the time check configuration of queued SDIM tickets.  A token with Org Admin or Service Desk Admin authority is required to access this endpoint.
		         * @summary Get the time check configuration
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getStatusCheckDetails: function (axiosOptions) {
		            return localVarFp.getStatusCheckDetails(axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Update an existing ServiceDeskIntegration by ID with a PATCH request.
		         * @summary Service Desk Integration Update PATCH
		         * @param {string} id ID of the Service Desk integration to update
		         * @param {PatchServiceDeskIntegrationRequestBeta} patchServiceDeskIntegrationRequestBeta A list of SDIM update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.  Only &#x60;replace&#x60; operations are accepted by this endpoint.  A 403 Forbidden Error indicates that you attempted to PATCH a operation that is not allowed.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchServiceDeskIntegration: function (id, patchServiceDeskIntegrationRequestBeta, axiosOptions) {
		            return localVarFp.patchServiceDeskIntegration(id, patchServiceDeskIntegrationRequestBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Update an existing Service Desk integration by ID with updated value in JSON form as the request body.  A token with Org Admin or Service Desk Admin authority is required to access this endpoint.
		         * @summary Update a Service Desk integration
		         * @param {string} id ID of the Service Desk integration to update
		         * @param {ServiceDeskIntegrationDtoBeta} serviceDeskIntegrationDtoBeta The specifics of the integration to update
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putServiceDeskIntegration: function (id, serviceDeskIntegrationDtoBeta, axiosOptions) {
		            return localVarFp.putServiceDeskIntegration(id, serviceDeskIntegrationDtoBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Update the time check configuration of queued SDIM tickets.  A token with Org Admin or Service Desk Admin authority is required to access this endpoint.
		         * @summary Update the time check configuration
		         * @param {QueuedCheckConfigDetailsBeta} queuedCheckConfigDetailsBeta the modified time check configuration
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateStatusCheckDetails: function (queuedCheckConfigDetailsBeta, axiosOptions) {
		            return localVarFp.updateStatusCheckDetails(queuedCheckConfigDetailsBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.ServiceDeskIntegrationBetaApiFactory = ServiceDeskIntegrationBetaApiFactory;
		/**
		 * ServiceDeskIntegrationBetaApi - object-oriented interface
		 * @export
		 * @class ServiceDeskIntegrationBetaApi
		 * @extends {BaseAPI}
		 */
		var ServiceDeskIntegrationBetaApi = /** @class */ (function (_super) {
		    __extends(ServiceDeskIntegrationBetaApi, _super);
		    function ServiceDeskIntegrationBetaApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * Create a new Service Desk Integrations.  A token with Org Admin or Service Desk Admin authority is required to access this endpoint.
		     * @summary Create new Service Desk integration
		     * @param {ServiceDeskIntegrationBetaApiCreateServiceDeskIntegrationRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof ServiceDeskIntegrationBetaApi
		     */
		    ServiceDeskIntegrationBetaApi.prototype.createServiceDeskIntegration = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.ServiceDeskIntegrationBetaApiFp)(this.configuration).createServiceDeskIntegration(requestParameters.serviceDeskIntegrationDtoBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Delete an existing Service Desk integration by ID.  A token with Org Admin or Service Desk Admin authority is required to access this endpoint.
		     * @summary Delete a Service Desk integration
		     * @param {ServiceDeskIntegrationBetaApiDeleteServiceDeskIntegrationRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof ServiceDeskIntegrationBetaApi
		     */
		    ServiceDeskIntegrationBetaApi.prototype.deleteServiceDeskIntegration = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.ServiceDeskIntegrationBetaApiFp)(this.configuration).deleteServiceDeskIntegration(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Get an existing Service Desk integration by ID.  A token with Org Admin or Service Desk Admin authority is required to access this endpoint.
		     * @summary Get a Service Desk integration
		     * @param {ServiceDeskIntegrationBetaApiGetServiceDeskIntegrationRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof ServiceDeskIntegrationBetaApi
		     */
		    ServiceDeskIntegrationBetaApi.prototype.getServiceDeskIntegration = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.ServiceDeskIntegrationBetaApiFp)(this.configuration).getServiceDeskIntegration(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Get a list of ServiceDeskIntegrationDto for existing Service Desk Integrations.  A token with Org Admin or Service Desk Admin authority is required to access this endpoint.
		     * @summary List existing Service Desk Integrations
		     * @param {ServiceDeskIntegrationBetaApiGetServiceDeskIntegrationListRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof ServiceDeskIntegrationBetaApi
		     */
		    ServiceDeskIntegrationBetaApi.prototype.getServiceDeskIntegrationList = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.ServiceDeskIntegrationBetaApiFp)(this.configuration).getServiceDeskIntegrationList(requestParameters.offset, requestParameters.limit, requestParameters.sorters, requestParameters.filters, requestParameters.count, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API endpoint returns an existing Service Desk integration template by scriptName.  A token with Org Admin or Service Desk Admin authority is required to access this endpoint.
		     * @summary Service Desk integration template by scriptName.
		     * @param {ServiceDeskIntegrationBetaApiGetServiceDeskIntegrationTemplateRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof ServiceDeskIntegrationBetaApi
		     */
		    ServiceDeskIntegrationBetaApi.prototype.getServiceDeskIntegrationTemplate = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.ServiceDeskIntegrationBetaApiFp)(this.configuration).getServiceDeskIntegrationTemplate(requestParameters.scriptName, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API endpoint returns the current list of supported Service Desk integration types.  A token with Org Admin or Service Desk Admin authority is required to access this endpoint.
		     * @summary Service Desk Integration Types List.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof ServiceDeskIntegrationBetaApi
		     */
		    ServiceDeskIntegrationBetaApi.prototype.getServiceDeskIntegrationTypes = function (axiosOptions) {
		        var _this = this;
		        return (0, exports.ServiceDeskIntegrationBetaApiFp)(this.configuration).getServiceDeskIntegrationTypes(axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Get the time check configuration of queued SDIM tickets.  A token with Org Admin or Service Desk Admin authority is required to access this endpoint.
		     * @summary Get the time check configuration
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof ServiceDeskIntegrationBetaApi
		     */
		    ServiceDeskIntegrationBetaApi.prototype.getStatusCheckDetails = function (axiosOptions) {
		        var _this = this;
		        return (0, exports.ServiceDeskIntegrationBetaApiFp)(this.configuration).getStatusCheckDetails(axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Update an existing ServiceDeskIntegration by ID with a PATCH request.
		     * @summary Service Desk Integration Update PATCH
		     * @param {ServiceDeskIntegrationBetaApiPatchServiceDeskIntegrationRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof ServiceDeskIntegrationBetaApi
		     */
		    ServiceDeskIntegrationBetaApi.prototype.patchServiceDeskIntegration = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.ServiceDeskIntegrationBetaApiFp)(this.configuration).patchServiceDeskIntegration(requestParameters.id, requestParameters.patchServiceDeskIntegrationRequestBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Update an existing Service Desk integration by ID with updated value in JSON form as the request body.  A token with Org Admin or Service Desk Admin authority is required to access this endpoint.
		     * @summary Update a Service Desk integration
		     * @param {ServiceDeskIntegrationBetaApiPutServiceDeskIntegrationRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof ServiceDeskIntegrationBetaApi
		     */
		    ServiceDeskIntegrationBetaApi.prototype.putServiceDeskIntegration = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.ServiceDeskIntegrationBetaApiFp)(this.configuration).putServiceDeskIntegration(requestParameters.id, requestParameters.serviceDeskIntegrationDtoBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Update the time check configuration of queued SDIM tickets.  A token with Org Admin or Service Desk Admin authority is required to access this endpoint.
		     * @summary Update the time check configuration
		     * @param {ServiceDeskIntegrationBetaApiUpdateStatusCheckDetailsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof ServiceDeskIntegrationBetaApi
		     */
		    ServiceDeskIntegrationBetaApi.prototype.updateStatusCheckDetails = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.ServiceDeskIntegrationBetaApiFp)(this.configuration).updateStatusCheckDetails(requestParameters.queuedCheckConfigDetailsBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return ServiceDeskIntegrationBetaApi;
		}(base_1.BaseAPI));
		exports.ServiceDeskIntegrationBetaApi = ServiceDeskIntegrationBetaApi;
		/**
		 * SourceUsagesBetaApi - axios parameter creator
		 * @export
		 */
		var SourceUsagesBetaApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * This API returns the status of the source usage insights setup by IDN source ID.
		         * @summary Finds status of source usage
		         * @param {string} sourceId ID of IDN source
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getStatusBySourceId: function (sourceId, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'sourceId' is not null or undefined
		                            (0, common_1.assertParamExists)('getStatusBySourceId', 'sourceId', sourceId);
		                            localVarPath = "/source-usages/{sourceId}/status"
		                                .replace("{".concat("sourceId", "}"), encodeURIComponent(String(sourceId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns a summary of source usage insights for past 12 months.
		         * @summary Returns source usage insights
		         * @param {string} sourceId ID of IDN source
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **date**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getUsagesBySourceId: function (sourceId, limit, offset, count, sorters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'sourceId' is not null or undefined
		                            (0, common_1.assertParamExists)('getUsagesBySourceId', 'sourceId', sourceId);
		                            localVarPath = "/source-usages/{sourceId}/summaries"
		                                .replace("{".concat("sourceId", "}"), encodeURIComponent(String(sourceId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.SourceUsagesBetaApiAxiosParamCreator = SourceUsagesBetaApiAxiosParamCreator;
		/**
		 * SourceUsagesBetaApi - functional programming interface
		 * @export
		 */
		var SourceUsagesBetaApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.SourceUsagesBetaApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * This API returns the status of the source usage insights setup by IDN source ID.
		         * @summary Finds status of source usage
		         * @param {string} sourceId ID of IDN source
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getStatusBySourceId: function (sourceId, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getStatusBySourceId(sourceId, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns a summary of source usage insights for past 12 months.
		         * @summary Returns source usage insights
		         * @param {string} sourceId ID of IDN source
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **date**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getUsagesBySourceId: function (sourceId, limit, offset, count, sorters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getUsagesBySourceId(sourceId, limit, offset, count, sorters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.SourceUsagesBetaApiFp = SourceUsagesBetaApiFp;
		/**
		 * SourceUsagesBetaApi - factory interface
		 * @export
		 */
		var SourceUsagesBetaApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.SourceUsagesBetaApiFp)(configuration);
		    return {
		        /**
		         * This API returns the status of the source usage insights setup by IDN source ID.
		         * @summary Finds status of source usage
		         * @param {string} sourceId ID of IDN source
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getStatusBySourceId: function (sourceId, axiosOptions) {
		            return localVarFp.getStatusBySourceId(sourceId, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API returns a summary of source usage insights for past 12 months.
		         * @summary Returns source usage insights
		         * @param {string} sourceId ID of IDN source
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **date**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getUsagesBySourceId: function (sourceId, limit, offset, count, sorters, axiosOptions) {
		            return localVarFp.getUsagesBySourceId(sourceId, limit, offset, count, sorters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.SourceUsagesBetaApiFactory = SourceUsagesBetaApiFactory;
		/**
		 * SourceUsagesBetaApi - object-oriented interface
		 * @export
		 * @class SourceUsagesBetaApi
		 * @extends {BaseAPI}
		 */
		var SourceUsagesBetaApi = /** @class */ (function (_super) {
		    __extends(SourceUsagesBetaApi, _super);
		    function SourceUsagesBetaApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * This API returns the status of the source usage insights setup by IDN source ID.
		     * @summary Finds status of source usage
		     * @param {SourceUsagesBetaApiGetStatusBySourceIdRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SourceUsagesBetaApi
		     */
		    SourceUsagesBetaApi.prototype.getStatusBySourceId = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SourceUsagesBetaApiFp)(this.configuration).getStatusBySourceId(requestParameters.sourceId, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API returns a summary of source usage insights for past 12 months.
		     * @summary Returns source usage insights
		     * @param {SourceUsagesBetaApiGetUsagesBySourceIdRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SourceUsagesBetaApi
		     */
		    SourceUsagesBetaApi.prototype.getUsagesBySourceId = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SourceUsagesBetaApiFp)(this.configuration).getUsagesBySourceId(requestParameters.sourceId, requestParameters.limit, requestParameters.offset, requestParameters.count, requestParameters.sorters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return SourceUsagesBetaApi;
		}(base_1.BaseAPI));
		exports.SourceUsagesBetaApi = SourceUsagesBetaApi;
		/**
		 * SourcesBetaApi - axios parameter creator
		 * @export
		 */
		var SourcesBetaApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * This end-point deletes a specific source in IdentityNow. A token with ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API. All of accounts on the source will be removed first, then the source will be deleted. Actual status of task execution can be retrieved via method GET `/task-status/{id}`
		         * @summary Delete Source by ID
		         * @param {string} id The Source ID
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        _delete: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('_delete', 'id', id);
		                            localVarPath = "/sources/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'DELETE' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API generates a create policy/template based on field value transforms. This API is intended for use when setting up JDBC Provisioning type sources, but it will also work on other source types. Transforms can be used in the provisioning policy to create a new attribute that you only need during provisioning. Refer to [Transforms in Provisioning Policies](https://developer.sailpoint.com/idn/docs/transforms/guides/transforms-in-provisioning-policies) for more information. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Create Provisioning Policy
		         * @param {string} sourceId The Source id
		         * @param {ProvisioningPolicyDtoBeta} provisioningPolicyDtoBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createProvisioningPolicy: function (sourceId, provisioningPolicyDtoBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'sourceId' is not null or undefined
		                            (0, common_1.assertParamExists)('createProvisioningPolicy', 'sourceId', sourceId);
		                            // verify required parameter 'provisioningPolicyDtoBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('createProvisioningPolicy', 'provisioningPolicyDtoBeta', provisioningPolicyDtoBeta);
		                            localVarPath = "/sources/{sourceId}/provisioning-policies"
		                                .replace("{".concat("sourceId", "}"), encodeURIComponent(String(sourceId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(provisioningPolicyDtoBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This creates a specific source with a full source JSON representation. Any passwords are submitted as plain-text and encrypted upon receipt in IdentityNow. A token with ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		         * @summary Creates a source in IdentityNow.
		         * @param {SourceBeta} sourceBeta
		         * @param {boolean} [provisionAsCsv] If this parameter is &#x60;true&#x60;, it configures the source as a Delimited File (CSV) source. Setting this to &#x60;true&#x60; will automatically set the &#x60;type&#x60; of the source to &#x60;DelimitedFile&#x60;.  You must use this query parameter to create a Delimited File source as you would in the UI.  If you don\&#39;t set this query parameter and you attempt to set the &#x60;type&#x60; attribute directly, the request won\&#39;t correctly generate the source.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createSource: function (sourceBeta, provisionAsCsv, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'sourceBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('createSource', 'sourceBeta', sourceBeta);
		                            localVarPath = "/sources";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (provisionAsCsv !== undefined) {
		                                localVarQueryParameter['provisionAsCsv'] = provisionAsCsv;
		                            }
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(sourceBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         *
		         * @summary Creates a new Schema on the specified Source in IdentityNow.
		         * @param {string} sourceId The Source id.
		         * @param {SchemaBeta} schemaBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createSourceSchema: function (sourceId, schemaBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'sourceId' is not null or undefined
		                            (0, common_1.assertParamExists)('createSourceSchema', 'sourceId', sourceId);
		                            // verify required parameter 'schemaBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('createSourceSchema', 'schemaBeta', schemaBeta);
		                            localVarPath = "/sources/{sourceId}/schemas"
		                                .replace("{".concat("sourceId", "}"), encodeURIComponent(String(sourceId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(schemaBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Deletes the native change detection configuration for the source specified by the given ID. A token with API, or ORG_ADMIN authority is required to call this API.
		         * @summary Delete Native Change Detection Configuration
		         * @param {string} id The source id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteNativeChangeDetectionConfig: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('deleteNativeChangeDetectionConfig', 'id', id);
		                            localVarPath = "/sources/{sourceId}/native-change-detection-config"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'DELETE' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Deletes the provisioning policy with the specified usage on an application. A token with API, or ORG_ADMIN authority is required to call this API.
		         * @summary Delete Provisioning Policy by UsageType
		         * @param {string} sourceId The Source ID.
		         * @param {UsageTypeBeta} usageType The type of provisioning policy usage.  In IdentityNow, a source can support various provisioning operations. For example, when a joiner is added to a source, this may trigger both CREATE and UPDATE provisioning operations.  Each usage type is considered a provisioning policy.  A source can have any number of these provisioning policies defined.  These are the common usage types:  CREATE - This usage type relates to \&#39;Create Account Profile\&#39;, the provisioning template for the account to be created. For example, this would be used for a joiner on a source.   UPDATE - This usage type relates to \&#39;Update Account Profile\&#39;, the provisioning template for the \&#39;Update\&#39; connector operations. For example, this would be used for an attribute sync on a source. ENABLE - This usage type relates to \&#39;Enable Account Profile\&#39;, the provisioning template for the account to be enabled. For example, this could be used for a joiner on a source once the joiner\&#39;s account is created.  DISABLE - This usage type relates to \&#39;Disable Account Profile\&#39;, the provisioning template for the account to be disabled. For example, this could be used when a leaver is removed temporarily from a source.  You can use these four usage types for all your provisioning policy needs.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteProvisioningPolicy: function (sourceId, usageType, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'sourceId' is not null or undefined
		                            (0, common_1.assertParamExists)('deleteProvisioningPolicy', 'sourceId', sourceId);
		                            // verify required parameter 'usageType' is not null or undefined
		                            (0, common_1.assertParamExists)('deleteProvisioningPolicy', 'usageType', usageType);
		                            localVarPath = "/sources/{sourceId}/provisioning-policies/{usageType}"
		                                .replace("{".concat("sourceId", "}"), encodeURIComponent(String(sourceId)))
		                                .replace("{".concat("usageType", "}"), encodeURIComponent(String(usageType)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'DELETE' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         *
		         * @summary Delete Source Schema by ID
		         * @param {string} sourceId The Source ID.
		         * @param {string} schemaId The Schema ID.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteSourceSchema: function (sourceId, schemaId, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'sourceId' is not null or undefined
		                            (0, common_1.assertParamExists)('deleteSourceSchema', 'sourceId', sourceId);
		                            // verify required parameter 'schemaId' is not null or undefined
		                            (0, common_1.assertParamExists)('deleteSourceSchema', 'schemaId', schemaId);
		                            localVarPath = "/sources/{sourceId}/schemas/{schemaId}"
		                                .replace("{".concat("sourceId", "}"), encodeURIComponent(String(sourceId)))
		                                .replace("{".concat("schemaId", "}"), encodeURIComponent(String(schemaId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'DELETE' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns the existing native change detection configuration for a source specified by the given ID. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Native Change Detection Configuration
		         * @param {string} id The source id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getNativeChangeDetectionConfig: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getNativeChangeDetectionConfig', 'id', id);
		                            localVarPath = "/sources/{sourceId}/native-change-detection-config"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This end-point retrieves the ProvisioningPolicy with the specified usage on the specified Source in IdentityNow. A token with API, ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		         * @summary Get Provisioning Policy by UsageType
		         * @param {string} sourceId The Source ID.
		         * @param {UsageTypeBeta} usageType The type of provisioning policy usage.  In IdentityNow, a source can support various provisioning operations. For example, when a joiner is added to a source, this may trigger both CREATE and UPDATE provisioning operations.  Each usage type is considered a provisioning policy.  A source can have any number of these provisioning policies defined.  These are the common usage types:  CREATE - This usage type relates to \&#39;Create Account Profile\&#39;, the provisioning template for the account to be created. For example, this would be used for a joiner on a source.   UPDATE - This usage type relates to \&#39;Update Account Profile\&#39;, the provisioning template for the \&#39;Update\&#39; connector operations. For example, this would be used for an attribute sync on a source. ENABLE - This usage type relates to \&#39;Enable Account Profile\&#39;, the provisioning template for the account to be enabled. For example, this could be used for a joiner on a source once the joiner\&#39;s account is created.  DISABLE - This usage type relates to \&#39;Disable Account Profile\&#39;, the provisioning template for the account to be disabled. For example, this could be used when a leaver is removed temporarily from a source.  You can use these four usage types for all your provisioning policy needs.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getProvisioningPolicy: function (sourceId, usageType, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'sourceId' is not null or undefined
		                            (0, common_1.assertParamExists)('getProvisioningPolicy', 'sourceId', sourceId);
		                            // verify required parameter 'usageType' is not null or undefined
		                            (0, common_1.assertParamExists)('getProvisioningPolicy', 'usageType', usageType);
		                            localVarPath = "/sources/{sourceId}/provisioning-policies/{usageType}"
		                                .replace("{".concat("sourceId", "}"), encodeURIComponent(String(sourceId)))
		                                .replace("{".concat("usageType", "}"), encodeURIComponent(String(usageType)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This end-point gets a specific source in IdentityNow. A token with ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		         * @summary Get Source by ID
		         * @param {string} id The Source ID
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getSource: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getSource', 'id', id);
		                            localVarPath = "/sources/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         *
		         * @summary Downloads source accounts schema template
		         * @param {string} id The Source id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getSourceAccountsSchema: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getSourceAccountsSchema', 'id', id);
		                            localVarPath = "/sources/{id}/schemas/accounts"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns the existing attribute synchronization configuration for a source specified by the given ID. The response contains all attributes, regardless of whether they enabled or not. A token with ORG_ADMIN or HELPDESK authority is required to call this API.
		         * @summary Attribute Sync Config
		         * @param {string} id The source id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getSourceAttrSyncConfig: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getSourceAttrSyncConfig', 'id', id);
		                            localVarPath = "/sources/{id}/attribute-sync-config"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Looks up and returns the source config for the requested source id after populating the source config values and applying language translations. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Gets source config with language translations
		         * @param {string} id The Source id
		         * @param {'de' | 'false' | 'fi' | 'sv' | 'ru' | 'pt' | 'ko' | 'zh-TW' | 'en' | 'it' | 'fr' | 'zh-CN' | 'hu' | 'es' | 'cs' | 'ja' | 'pl' | 'da' | 'nl'} [locale] The locale to apply to the config. If no viable locale is given, it will default to \&quot;en\&quot;
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getSourceConfig: function (id, locale, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getSourceConfig', 'id', id);
		                            localVarPath = "/sources/{id}/connectors/source-config"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (locale !== undefined) {
		                                localVarQueryParameter['locale'] = locale;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API gets the current entitlement request configuration for a source. This source-level configuration should apply for all the entitlements in the source.  Access request to any entitlements in the source should follow this configuration unless a separate entitlement-level configuration is defined. - During access request, this source-level entitlement request configuration overrides the global organization-level configuration. - However, the entitlement-level configuration (if defined) overrides this source-level configuration.  A token with ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		         * @summary Get Source Entitlement Request Configuration
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getSourceEntitlementRequestConfig: function (axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/sources/{id}/entitlement-request-config";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         *
		         * @summary Downloads source entitlements schema template
		         * @param {string} id The Source id
		         * @param {string} [schemaName] Name of entitlement schema
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getSourceEntitlementsSchema: function (id, schemaName, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getSourceEntitlementsSchema', 'id', id);
		                            localVarPath = "/sources/{id}/schemas/entitlements"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (schemaName !== undefined) {
		                                localVarQueryParameter['schemaName'] = schemaName;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Get the Source Schema by ID in IdentityNow.
		         * @summary Get Source Schema by ID
		         * @param {string} sourceId The Source ID.
		         * @param {string} schemaId The Schema ID.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getSourceSchema: function (sourceId, schemaId, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'sourceId' is not null or undefined
		                            (0, common_1.assertParamExists)('getSourceSchema', 'sourceId', sourceId);
		                            // verify required parameter 'schemaId' is not null or undefined
		                            (0, common_1.assertParamExists)('getSourceSchema', 'schemaId', schemaId);
		                            localVarPath = "/sources/{sourceId}/schemas/{schemaId}"
		                                .replace("{".concat("sourceId", "}"), encodeURIComponent(String(sourceId)))
		                                .replace("{".concat("schemaId", "}"), encodeURIComponent(String(schemaId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API uploads a source schema template file to configure a source\'s account attributes.
		         * @summary Uploads source accounts schema template
		         * @param {string} id The Source id
		         * @param {any} [file]
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        importSourceAccountsSchema: function (id, file, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, localVarFormParams, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('importSourceAccountsSchema', 'id', id);
		                            localVarPath = "/sources/{id}/schemas/accounts"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            localVarFormParams = new ((configuration && configuration.formDataCtor) || FormData)();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (file !== undefined) {
		                                localVarFormParams.append('file', file);
		                            }
		                            localVarHeaderParameter['Content-Type'] = 'multipart/form-data';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = localVarFormParams;
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This uploads a supplemental source connector file (like jdbc driver jars) to a source\'s S3 bucket. This also sends ETS and Audit events. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Upload connector file to source
		         * @param {string} sourceId The Source id
		         * @param {any} [file]
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        importSourceConnectorFile: function (sourceId, file, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, localVarFormParams, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'sourceId' is not null or undefined
		                            (0, common_1.assertParamExists)('importSourceConnectorFile', 'sourceId', sourceId);
		                            localVarPath = "/sources/{sourceId}/upload-connector-file"
		                                .replace("{".concat("sourceId", "}"), encodeURIComponent(String(sourceId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            localVarFormParams = new ((configuration && configuration.formDataCtor) || FormData)();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (file !== undefined) {
		                                localVarFormParams.append('file', file);
		                            }
		                            localVarHeaderParameter['Content-Type'] = 'multipart/form-data';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = localVarFormParams;
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API uploads a source schema template file to configure a source\'s entitlement attributes.
		         * @summary Uploads source entitlements schema template
		         * @param {string} id The Source id
		         * @param {string} [schemaName] Name of entitlement schema
		         * @param {any} [file]
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        importSourceEntitlementsSchema: function (id, schemaName, file, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, localVarFormParams, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('importSourceEntitlementsSchema', 'id', id);
		                            localVarPath = "/sources/{id}/schemas/entitlements"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            localVarFormParams = new ((configuration && configuration.formDataCtor) || FormData)();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (schemaName !== undefined) {
		                                localVarQueryParameter['schemaName'] = schemaName;
		                            }
		                            if (file !== undefined) {
		                                localVarFormParams.append('file', file);
		                            }
		                            localVarHeaderParameter['Content-Type'] = 'multipart/form-data';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = localVarFormParams;
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This end-point lists all the ProvisioningPolicies in IdentityNow. A token with API, or ORG_ADMIN authority is required to call this API.
		         * @summary Lists ProvisioningPolicies
		         * @param {string} sourceId The Source id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listProvisioningPolicies: function (sourceId, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'sourceId' is not null or undefined
		                            (0, common_1.assertParamExists)('listProvisioningPolicies', 'sourceId', sourceId);
		                            localVarPath = "/sources/{sourceId}/provisioning-policies"
		                                .replace("{".concat("sourceId", "}"), encodeURIComponent(String(sourceId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         *
		         * @summary Lists the Schemas that exist on the specified Source in IdentityNow.
		         * @param {string} sourceId The Source id.
		         * @param {string} [includeTypes] If set to \&#39;group\&#39;, then the account schema is filtered and only group schemas are returned. Only a value of \&#39;group\&#39; is recognized.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listSourceSchemas: function (sourceId, includeTypes, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'sourceId' is not null or undefined
		                            (0, common_1.assertParamExists)('listSourceSchemas', 'sourceId', sourceId);
		                            localVarPath = "/sources/{sourceId}/schemas"
		                                .replace("{".concat("sourceId", "}"), encodeURIComponent(String(sourceId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (includeTypes !== undefined) {
		                                localVarQueryParameter['include-types'] = includeTypes;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This end-point lists all the sources in IdentityNow.  A token with ORG_ADMIN, SOURCE_ADMIN, SOURCE_SUBADMIN, or ROLE_SUBADMIN authority is required to call this API.
		         * @summary Lists all sources in IdentityNow.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in, ge, gt, le, lt, ne, isnull, sw*  **name**: *co, eq, in, sw, ge, gt, ne, isnull*  **type**: *eq, in, ge, gt, ne, isnull, sw*  **owner.id**: *eq, in, ge, gt, le, lt, ne, isnull, sw*  **features**: *ca, co*  **created**: *eq*  **modified**: *eq*  **managementWorkgroup.id**: *eq, ge, gt, in, le, lt, ne, isnull, sw*  **description**: *eq, sw*  **authoritative**: *eq, ne, isnull*  **healthy**: *isnull*  **status**: *eq, in, ge, gt, le, lt, ne, isnull, sw*  **connectionType**: *eq, ge, gt, in, le, lt, ne, isnull, sw*  **connectorName**: *eq, ge, gt, in, ne, isnull, sw*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **type, created, modified, name, owner.name, healthy, status, id, description, owner.id, accountCorrelationConfig.id, accountCorrelationConfig.name, managerCorrelationRule.type, managerCorrelationRule.id, managerCorrelationRule.name, authoritative, managementWorkgroup.id, connectorName, connectionType**
		         * @param {string} [forSubadmin] Filter the returned list of sources for the identity specified by the parameter, which is the id of an identity with the role SOURCE_SUBADMIN. By convention, the value **me** indicates the identity id of the current user. Subadmins may only view Sources which they are able to administer; all other Sources will be filtered out when this parameter is set. If the current user is a SOURCE_SUBADMIN but fails to pass a valid value for this parameter, a 403 Forbidden is returned.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listSources: function (limit, offset, count, filters, sorters, forSubadmin, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/sources";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            if (forSubadmin !== undefined) {
		                                localVarQueryParameter['for-subadmin'] = forSubadmin;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Retrieves a sample of data returned from account and group aggregation requests. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Peek source connector\'s resource objects
		         * @param {string} sourceId The ID of the Source
		         * @param {ResourceObjectsRequestBeta} resourceObjectsRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        peekResourceObjects: function (sourceId, resourceObjectsRequestBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'sourceId' is not null or undefined
		                            (0, common_1.assertParamExists)('peekResourceObjects', 'sourceId', sourceId);
		                            // verify required parameter 'resourceObjectsRequestBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('peekResourceObjects', 'resourceObjectsRequestBeta', resourceObjectsRequestBeta);
		                            localVarPath = "/sources/{sourceId}/connector/peek-resource-objects"
		                                .replace("{".concat("sourceId", "}"), encodeURIComponent(String(sourceId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(resourceObjectsRequestBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This endpoint validates that the cluster being used by the source is reachable from IdentityNow. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Ping cluster for source connector
		         * @param {string} sourceId The ID of the Source
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        pingCluster: function (sourceId, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'sourceId' is not null or undefined
		                            (0, common_1.assertParamExists)('pingCluster', 'sourceId', sourceId);
		                            localVarPath = "/sources/{sourceId}/connector/ping-cluster"
		                                .replace("{".concat("sourceId", "}"), encodeURIComponent(String(sourceId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Replaces the native change detection configuration for the source specified by the given ID with the configuration provided in the request body.      A token with ORG_ADMIN authority is required to call this API.
		         * @summary Update Native Change Detection Configuration
		         * @param {string} id The source id
		         * @param {NativeChangeDetectionConfigBeta} nativeChangeDetectionConfigBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putNativeChangeDetectionConfig: function (id, nativeChangeDetectionConfigBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('putNativeChangeDetectionConfig', 'id', id);
		                            // verify required parameter 'nativeChangeDetectionConfigBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('putNativeChangeDetectionConfig', 'nativeChangeDetectionConfigBeta', nativeChangeDetectionConfigBeta);
		                            localVarPath = "/sources/{sourceId}/native-change-detection-config"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PUT' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(nativeChangeDetectionConfigBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This end-point updates the provisioning policy with the specified usage on the specified source in IdentityNow. Transforms can be used in the provisioning policy to create a new attribute that you only need during provisioning. Refer to [Transforms in Provisioning Policies](https://developer.sailpoint.com/idn/docs/transforms/guides/transforms-in-provisioning-policies) for more information. A token with API, ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		         * @summary Update Provisioning Policy by UsageType
		         * @param {string} sourceId The Source ID.
		         * @param {UsageTypeBeta} usageType The type of provisioning policy usage.  In IdentityNow, a source can support various provisioning operations. For example, when a joiner is added to a source, this may trigger both CREATE and UPDATE provisioning operations.  Each usage type is considered a provisioning policy.  A source can have any number of these provisioning policies defined.  These are the common usage types:  CREATE - This usage type relates to \&#39;Create Account Profile\&#39;, the provisioning template for the account to be created. For example, this would be used for a joiner on a source.   UPDATE - This usage type relates to \&#39;Update Account Profile\&#39;, the provisioning template for the \&#39;Update\&#39; connector operations. For example, this would be used for an attribute sync on a source. ENABLE - This usage type relates to \&#39;Enable Account Profile\&#39;, the provisioning template for the account to be enabled. For example, this could be used for a joiner on a source once the joiner\&#39;s account is created.  DISABLE - This usage type relates to \&#39;Disable Account Profile\&#39;, the provisioning template for the account to be disabled. For example, this could be used when a leaver is removed temporarily from a source.  You can use these four usage types for all your provisioning policy needs.
		         * @param {ProvisioningPolicyDtoBeta} provisioningPolicyDtoBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putProvisioningPolicy: function (sourceId, usageType, provisioningPolicyDtoBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'sourceId' is not null or undefined
		                            (0, common_1.assertParamExists)('putProvisioningPolicy', 'sourceId', sourceId);
		                            // verify required parameter 'usageType' is not null or undefined
		                            (0, common_1.assertParamExists)('putProvisioningPolicy', 'usageType', usageType);
		                            // verify required parameter 'provisioningPolicyDtoBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('putProvisioningPolicy', 'provisioningPolicyDtoBeta', provisioningPolicyDtoBeta);
		                            localVarPath = "/sources/{sourceId}/provisioning-policies/{usageType}"
		                                .replace("{".concat("sourceId", "}"), encodeURIComponent(String(sourceId)))
		                                .replace("{".concat("usageType", "}"), encodeURIComponent(String(usageType)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PUT' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(provisioningPolicyDtoBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API updates a source in IdentityNow, using a full object representation. In other words, the existing Source configuration is completely replaced.  Some fields are immutable and cannot be changed, such as:  * id * type * authoritative * connector * connectorClass * passwordPolicies  Attempts to modify these fields will result in a 400 error.  A token with ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		         * @summary Update Source (Full)
		         * @param {string} id The Source id
		         * @param {SourceBeta} sourceBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putSource: function (id, sourceBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('putSource', 'id', id);
		                            // verify required parameter 'sourceBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('putSource', 'sourceBeta', sourceBeta);
		                            localVarPath = "/sources/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PUT' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(sourceBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Replaces the attribute synchronization configuration for the source specified by the given ID with the configuration provided in the request body. Only the \"enabled\" field of the values in the \"attributes\" array is mutable. Attempting to change other attributes or add new values to the \"attributes\" array will result in an error.      A token with ORG_ADMIN authority is required to call this API.
		         * @summary Update Attribute Sync Config
		         * @param {string} id The source id
		         * @param {AttrSyncSourceConfigBeta} attrSyncSourceConfigBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putSourceAttrSyncConfig: function (id, attrSyncSourceConfigBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('putSourceAttrSyncConfig', 'id', id);
		                            // verify required parameter 'attrSyncSourceConfigBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('putSourceAttrSyncConfig', 'attrSyncSourceConfigBeta', attrSyncSourceConfigBeta);
		                            localVarPath = "/sources/{id}/attribute-sync-config"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PUT' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(attrSyncSourceConfigBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API will completely replace an existing Schema with the submitted payload. Some fields of the Schema cannot be updated. These fields are listed below. * id * name * created * modified Any attempt to modify these fields will result in an error response with a status code of 400.
		         * @summary Update Source Schema (Full)
		         * @param {string} sourceId The Source ID.
		         * @param {string} schemaId The Schema ID.
		         * @param {SchemaBeta} schemaBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putSourceSchema: function (sourceId, schemaId, schemaBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'sourceId' is not null or undefined
		                            (0, common_1.assertParamExists)('putSourceSchema', 'sourceId', sourceId);
		                            // verify required parameter 'schemaId' is not null or undefined
		                            (0, common_1.assertParamExists)('putSourceSchema', 'schemaId', schemaId);
		                            // verify required parameter 'schemaBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('putSourceSchema', 'schemaBeta', schemaBeta);
		                            localVarPath = "/sources/{sourceId}/schemas/{schemaId}"
		                                .replace("{".concat("sourceId", "}"), encodeURIComponent(String(sourceId)))
		                                .replace("{".concat("schemaId", "}"), encodeURIComponent(String(schemaId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PUT' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(schemaBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This end-point performs attribute synchronization for a selected source. A token with ORG_ADMIN or SOURCE_ADMIN authority is required to call this API.
		         * @summary Synchronize single source attributes.
		         * @param {string} id The Source id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        syncAttributesForSource: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('syncAttributesForSource', 'id', id);
		                            localVarPath = "/sources/{id}/synchronize-attributes"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This endpoint performs a more detailed validation of the source\'s configuration that can take longer than the lighter weight credential validation performed by the checkConnection API. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Test configuration for source connector
		         * @param {string} sourceId The ID of the Source
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        testSourceConfiguration: function (sourceId, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'sourceId' is not null or undefined
		                            (0, common_1.assertParamExists)('testSourceConfiguration', 'sourceId', sourceId);
		                            localVarPath = "/sources/{sourceId}/connector/test-configuration"
		                                .replace("{".concat("sourceId", "}"), encodeURIComponent(String(sourceId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This endpoint validates that the configured credentials are valid and will properly authenticate with the source identified by the sourceId path parameter. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Check connection for source connector.
		         * @param {string} sourceId The ID of the Source.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        testSourceConnection: function (sourceId, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'sourceId' is not null or undefined
		                            (0, common_1.assertParamExists)('testSourceConnection', 'sourceId', sourceId);
		                            localVarPath = "/sources/{sourceId}/connector/check-connection"
		                                .replace("{".concat("sourceId", "}"), encodeURIComponent(String(sourceId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This end-point updates a list of provisioning policies on the specified source in IdentityNow. A token with API, or ORG_ADMIN authority is required to call this API.
		         * @summary Bulk Update Provisioning Policies
		         * @param {string} sourceId The Source id.
		         * @param {Array<ProvisioningPolicyDtoBeta>} provisioningPolicyDtoBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateProvisioningPoliciesInBulk: function (sourceId, provisioningPolicyDtoBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'sourceId' is not null or undefined
		                            (0, common_1.assertParamExists)('updateProvisioningPoliciesInBulk', 'sourceId', sourceId);
		                            // verify required parameter 'provisioningPolicyDtoBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('updateProvisioningPoliciesInBulk', 'provisioningPolicyDtoBeta', provisioningPolicyDtoBeta);
		                            localVarPath = "/sources/{sourceId}/provisioning-policies/bulk-update"
		                                .replace("{".concat("sourceId", "}"), encodeURIComponent(String(sourceId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(provisioningPolicyDtoBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API selectively updates an existing Provisioning Policy using a JSONPatch payload. Transforms can be used in the provisioning policy to create a new attribute that you only need during provisioning. Refer to [Transforms in Provisioning Policies](https://developer.sailpoint.com/idn/docs/transforms/guides/transforms-in-provisioning-policies) for more information. A token with API, ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		         * @summary Partial update of Provisioning Policy
		         * @param {string} sourceId The Source id.
		         * @param {UsageTypeBeta} usageType The type of provisioning policy usage.  In IdentityNow, a source can support various provisioning operations. For example, when a joiner is added to a source, this may trigger both CREATE and UPDATE provisioning operations.  Each usage type is considered a provisioning policy.  A source can have any number of these provisioning policies defined.  These are the common usage types:  CREATE - This usage type relates to \&#39;Create Account Profile\&#39;, the provisioning template for the account to be created. For example, this would be used for a joiner on a source.   UPDATE - This usage type relates to \&#39;Update Account Profile\&#39;, the provisioning template for the \&#39;Update\&#39; connector operations. For example, this would be used for an attribute sync on a source. ENABLE - This usage type relates to \&#39;Enable Account Profile\&#39;, the provisioning template for the account to be enabled. For example, this could be used for a joiner on a source once the joiner\&#39;s account is created.  DISABLE - This usage type relates to \&#39;Disable Account Profile\&#39;, the provisioning template for the account to be disabled. For example, this could be used when a leaver is removed temporarily from a source.  You can use these four usage types for all your provisioning policy needs.
		         * @param {Array<JsonPatchOperationBeta>} jsonPatchOperationBeta The JSONPatch payload used to update the schema.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateProvisioningPolicy: function (sourceId, usageType, jsonPatchOperationBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'sourceId' is not null or undefined
		                            (0, common_1.assertParamExists)('updateProvisioningPolicy', 'sourceId', sourceId);
		                            // verify required parameter 'usageType' is not null or undefined
		                            (0, common_1.assertParamExists)('updateProvisioningPolicy', 'usageType', usageType);
		                            // verify required parameter 'jsonPatchOperationBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('updateProvisioningPolicy', 'jsonPatchOperationBeta', jsonPatchOperationBeta);
		                            localVarPath = "/sources/{sourceId}/provisioning-policies/{usageType}"
		                                .replace("{".concat("sourceId", "}"), encodeURIComponent(String(sourceId)))
		                                .replace("{".concat("usageType", "}"), encodeURIComponent(String(usageType)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PATCH' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json-patch+json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(jsonPatchOperationBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API partially updates a source in IdentityNow, using a list of patch operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.  Some fields are immutable and cannot be changed, such as: * id * type * authoritative * created * modified * connector * connectorClass * passwordPolicies  Attempts to modify these fields will result in a 400 error.  A token with ORG_ADMIN, SOURCE_ADMIN, SOURCE_SUBADMIN, or API authority is required to call this API.
		         * @summary Update Source (Partial)
		         * @param {string} id The Source id
		         * @param {Array<JsonPatchOperationBeta>} jsonPatchOperationBeta A list of account update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard. Any password changes are submitted as plain-text and encrypted upon receipt in IdentityNow.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateSource: function (id, jsonPatchOperationBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('updateSource', 'id', id);
		                            // verify required parameter 'jsonPatchOperationBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('updateSource', 'jsonPatchOperationBeta', jsonPatchOperationBeta);
		                            localVarPath = "/sources/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PATCH' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json-patch+json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(jsonPatchOperationBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API replaces the current entitlement request configuration for a source. This source-level configuration should apply for all the entitlements in the source.  Access request to any entitlements in the source should follow this configuration unless a separate entitlement-level configuration is defined. - During access request, this source-level entitlement request configuration overrides the global organization-level configuration. - However, the entitlement-level configuration (if defined) overrides this source-level configuration.  A token with ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		         * @summary Update Source Entitlement Request Configuration
		         * @param {SourceEntitlementRequestConfigBeta} sourceEntitlementRequestConfigBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateSourceEntitlementRequestConfig: function (sourceEntitlementRequestConfigBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'sourceEntitlementRequestConfigBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('updateSourceEntitlementRequestConfig', 'sourceEntitlementRequestConfigBeta', sourceEntitlementRequestConfigBeta);
		                            localVarPath = "/sources/{id}/entitlement-request-config";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PUT' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(sourceEntitlementRequestConfigBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Use this API to selectively update an existing Schema using a JSONPatch payload.   The following schema fields are immutable and cannot be updated:  - id - name - created - modified   To switch an account attribute to a group entitlement, you need to have the following in place:  - `isEntitlement: true` - Must define a schema for the group and [add it to the source](https://developer.sailpoint.com/idn/api/beta/create-source-schema) before updating the `isGroup` flag.  For example, here is the `group` account attribute referencing a schema that defines the group: ```json {     \"name\": \"groups\",     \"type\": \"STRING\",     \"schema\": {         \"type\": \"CONNECTOR_SCHEMA\",         \"id\": \"2c9180887671ff8c01767b4671fc7d60\",         \"name\": \"group\"     },     \"description\": \"The groups, roles etc. that reference account group objects\",     \"isMulti\": true,     \"isEntitlement\": true,     \"isGroup\": true } ```
		         * @summary Update Source Schema (Partial)
		         * @param {string} sourceId The Source id.
		         * @param {string} schemaId The Schema id.
		         * @param {Array<JsonPatchOperationBeta>} jsonPatchOperationBeta The JSONPatch payload used to update the schema.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateSourceSchema: function (sourceId, schemaId, jsonPatchOperationBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'sourceId' is not null or undefined
		                            (0, common_1.assertParamExists)('updateSourceSchema', 'sourceId', sourceId);
		                            // verify required parameter 'schemaId' is not null or undefined
		                            (0, common_1.assertParamExists)('updateSourceSchema', 'schemaId', schemaId);
		                            // verify required parameter 'jsonPatchOperationBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('updateSourceSchema', 'jsonPatchOperationBeta', jsonPatchOperationBeta);
		                            localVarPath = "/sources/{sourceId}/schemas/{schemaId}"
		                                .replace("{".concat("sourceId", "}"), encodeURIComponent(String(sourceId)))
		                                .replace("{".concat("schemaId", "}"), encodeURIComponent(String(schemaId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PATCH' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json-patch+json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(jsonPatchOperationBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.SourcesBetaApiAxiosParamCreator = SourcesBetaApiAxiosParamCreator;
		/**
		 * SourcesBetaApi - functional programming interface
		 * @export
		 */
		var SourcesBetaApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.SourcesBetaApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * This end-point deletes a specific source in IdentityNow. A token with ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API. All of accounts on the source will be removed first, then the source will be deleted. Actual status of task execution can be retrieved via method GET `/task-status/{id}`
		         * @summary Delete Source by ID
		         * @param {string} id The Source ID
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        _delete: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator._delete(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API generates a create policy/template based on field value transforms. This API is intended for use when setting up JDBC Provisioning type sources, but it will also work on other source types. Transforms can be used in the provisioning policy to create a new attribute that you only need during provisioning. Refer to [Transforms in Provisioning Policies](https://developer.sailpoint.com/idn/docs/transforms/guides/transforms-in-provisioning-policies) for more information. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Create Provisioning Policy
		         * @param {string} sourceId The Source id
		         * @param {ProvisioningPolicyDtoBeta} provisioningPolicyDtoBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createProvisioningPolicy: function (sourceId, provisioningPolicyDtoBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.createProvisioningPolicy(sourceId, provisioningPolicyDtoBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This creates a specific source with a full source JSON representation. Any passwords are submitted as plain-text and encrypted upon receipt in IdentityNow. A token with ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		         * @summary Creates a source in IdentityNow.
		         * @param {SourceBeta} sourceBeta
		         * @param {boolean} [provisionAsCsv] If this parameter is &#x60;true&#x60;, it configures the source as a Delimited File (CSV) source. Setting this to &#x60;true&#x60; will automatically set the &#x60;type&#x60; of the source to &#x60;DelimitedFile&#x60;.  You must use this query parameter to create a Delimited File source as you would in the UI.  If you don\&#39;t set this query parameter and you attempt to set the &#x60;type&#x60; attribute directly, the request won\&#39;t correctly generate the source.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createSource: function (sourceBeta, provisionAsCsv, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.createSource(sourceBeta, provisionAsCsv, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         *
		         * @summary Creates a new Schema on the specified Source in IdentityNow.
		         * @param {string} sourceId The Source id.
		         * @param {SchemaBeta} schemaBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createSourceSchema: function (sourceId, schemaBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.createSourceSchema(sourceId, schemaBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Deletes the native change detection configuration for the source specified by the given ID. A token with API, or ORG_ADMIN authority is required to call this API.
		         * @summary Delete Native Change Detection Configuration
		         * @param {string} id The source id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteNativeChangeDetectionConfig: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.deleteNativeChangeDetectionConfig(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Deletes the provisioning policy with the specified usage on an application. A token with API, or ORG_ADMIN authority is required to call this API.
		         * @summary Delete Provisioning Policy by UsageType
		         * @param {string} sourceId The Source ID.
		         * @param {UsageTypeBeta} usageType The type of provisioning policy usage.  In IdentityNow, a source can support various provisioning operations. For example, when a joiner is added to a source, this may trigger both CREATE and UPDATE provisioning operations.  Each usage type is considered a provisioning policy.  A source can have any number of these provisioning policies defined.  These are the common usage types:  CREATE - This usage type relates to \&#39;Create Account Profile\&#39;, the provisioning template for the account to be created. For example, this would be used for a joiner on a source.   UPDATE - This usage type relates to \&#39;Update Account Profile\&#39;, the provisioning template for the \&#39;Update\&#39; connector operations. For example, this would be used for an attribute sync on a source. ENABLE - This usage type relates to \&#39;Enable Account Profile\&#39;, the provisioning template for the account to be enabled. For example, this could be used for a joiner on a source once the joiner\&#39;s account is created.  DISABLE - This usage type relates to \&#39;Disable Account Profile\&#39;, the provisioning template for the account to be disabled. For example, this could be used when a leaver is removed temporarily from a source.  You can use these four usage types for all your provisioning policy needs.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteProvisioningPolicy: function (sourceId, usageType, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.deleteProvisioningPolicy(sourceId, usageType, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         *
		         * @summary Delete Source Schema by ID
		         * @param {string} sourceId The Source ID.
		         * @param {string} schemaId The Schema ID.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteSourceSchema: function (sourceId, schemaId, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.deleteSourceSchema(sourceId, schemaId, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns the existing native change detection configuration for a source specified by the given ID. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Native Change Detection Configuration
		         * @param {string} id The source id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getNativeChangeDetectionConfig: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getNativeChangeDetectionConfig(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This end-point retrieves the ProvisioningPolicy with the specified usage on the specified Source in IdentityNow. A token with API, ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		         * @summary Get Provisioning Policy by UsageType
		         * @param {string} sourceId The Source ID.
		         * @param {UsageTypeBeta} usageType The type of provisioning policy usage.  In IdentityNow, a source can support various provisioning operations. For example, when a joiner is added to a source, this may trigger both CREATE and UPDATE provisioning operations.  Each usage type is considered a provisioning policy.  A source can have any number of these provisioning policies defined.  These are the common usage types:  CREATE - This usage type relates to \&#39;Create Account Profile\&#39;, the provisioning template for the account to be created. For example, this would be used for a joiner on a source.   UPDATE - This usage type relates to \&#39;Update Account Profile\&#39;, the provisioning template for the \&#39;Update\&#39; connector operations. For example, this would be used for an attribute sync on a source. ENABLE - This usage type relates to \&#39;Enable Account Profile\&#39;, the provisioning template for the account to be enabled. For example, this could be used for a joiner on a source once the joiner\&#39;s account is created.  DISABLE - This usage type relates to \&#39;Disable Account Profile\&#39;, the provisioning template for the account to be disabled. For example, this could be used when a leaver is removed temporarily from a source.  You can use these four usage types for all your provisioning policy needs.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getProvisioningPolicy: function (sourceId, usageType, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getProvisioningPolicy(sourceId, usageType, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This end-point gets a specific source in IdentityNow. A token with ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		         * @summary Get Source by ID
		         * @param {string} id The Source ID
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getSource: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getSource(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         *
		         * @summary Downloads source accounts schema template
		         * @param {string} id The Source id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getSourceAccountsSchema: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getSourceAccountsSchema(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns the existing attribute synchronization configuration for a source specified by the given ID. The response contains all attributes, regardless of whether they enabled or not. A token with ORG_ADMIN or HELPDESK authority is required to call this API.
		         * @summary Attribute Sync Config
		         * @param {string} id The source id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getSourceAttrSyncConfig: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getSourceAttrSyncConfig(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Looks up and returns the source config for the requested source id after populating the source config values and applying language translations. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Gets source config with language translations
		         * @param {string} id The Source id
		         * @param {'de' | 'false' | 'fi' | 'sv' | 'ru' | 'pt' | 'ko' | 'zh-TW' | 'en' | 'it' | 'fr' | 'zh-CN' | 'hu' | 'es' | 'cs' | 'ja' | 'pl' | 'da' | 'nl'} [locale] The locale to apply to the config. If no viable locale is given, it will default to \&quot;en\&quot;
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getSourceConfig: function (id, locale, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getSourceConfig(id, locale, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API gets the current entitlement request configuration for a source. This source-level configuration should apply for all the entitlements in the source.  Access request to any entitlements in the source should follow this configuration unless a separate entitlement-level configuration is defined. - During access request, this source-level entitlement request configuration overrides the global organization-level configuration. - However, the entitlement-level configuration (if defined) overrides this source-level configuration.  A token with ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		         * @summary Get Source Entitlement Request Configuration
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getSourceEntitlementRequestConfig: function (axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getSourceEntitlementRequestConfig(axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         *
		         * @summary Downloads source entitlements schema template
		         * @param {string} id The Source id
		         * @param {string} [schemaName] Name of entitlement schema
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getSourceEntitlementsSchema: function (id, schemaName, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getSourceEntitlementsSchema(id, schemaName, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Get the Source Schema by ID in IdentityNow.
		         * @summary Get Source Schema by ID
		         * @param {string} sourceId The Source ID.
		         * @param {string} schemaId The Schema ID.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getSourceSchema: function (sourceId, schemaId, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getSourceSchema(sourceId, schemaId, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API uploads a source schema template file to configure a source\'s account attributes.
		         * @summary Uploads source accounts schema template
		         * @param {string} id The Source id
		         * @param {any} [file]
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        importSourceAccountsSchema: function (id, file, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.importSourceAccountsSchema(id, file, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This uploads a supplemental source connector file (like jdbc driver jars) to a source\'s S3 bucket. This also sends ETS and Audit events. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Upload connector file to source
		         * @param {string} sourceId The Source id
		         * @param {any} [file]
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        importSourceConnectorFile: function (sourceId, file, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.importSourceConnectorFile(sourceId, file, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API uploads a source schema template file to configure a source\'s entitlement attributes.
		         * @summary Uploads source entitlements schema template
		         * @param {string} id The Source id
		         * @param {string} [schemaName] Name of entitlement schema
		         * @param {any} [file]
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        importSourceEntitlementsSchema: function (id, schemaName, file, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.importSourceEntitlementsSchema(id, schemaName, file, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This end-point lists all the ProvisioningPolicies in IdentityNow. A token with API, or ORG_ADMIN authority is required to call this API.
		         * @summary Lists ProvisioningPolicies
		         * @param {string} sourceId The Source id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listProvisioningPolicies: function (sourceId, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listProvisioningPolicies(sourceId, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         *
		         * @summary Lists the Schemas that exist on the specified Source in IdentityNow.
		         * @param {string} sourceId The Source id.
		         * @param {string} [includeTypes] If set to \&#39;group\&#39;, then the account schema is filtered and only group schemas are returned. Only a value of \&#39;group\&#39; is recognized.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listSourceSchemas: function (sourceId, includeTypes, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listSourceSchemas(sourceId, includeTypes, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This end-point lists all the sources in IdentityNow.  A token with ORG_ADMIN, SOURCE_ADMIN, SOURCE_SUBADMIN, or ROLE_SUBADMIN authority is required to call this API.
		         * @summary Lists all sources in IdentityNow.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in, ge, gt, le, lt, ne, isnull, sw*  **name**: *co, eq, in, sw, ge, gt, ne, isnull*  **type**: *eq, in, ge, gt, ne, isnull, sw*  **owner.id**: *eq, in, ge, gt, le, lt, ne, isnull, sw*  **features**: *ca, co*  **created**: *eq*  **modified**: *eq*  **managementWorkgroup.id**: *eq, ge, gt, in, le, lt, ne, isnull, sw*  **description**: *eq, sw*  **authoritative**: *eq, ne, isnull*  **healthy**: *isnull*  **status**: *eq, in, ge, gt, le, lt, ne, isnull, sw*  **connectionType**: *eq, ge, gt, in, le, lt, ne, isnull, sw*  **connectorName**: *eq, ge, gt, in, ne, isnull, sw*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **type, created, modified, name, owner.name, healthy, status, id, description, owner.id, accountCorrelationConfig.id, accountCorrelationConfig.name, managerCorrelationRule.type, managerCorrelationRule.id, managerCorrelationRule.name, authoritative, managementWorkgroup.id, connectorName, connectionType**
		         * @param {string} [forSubadmin] Filter the returned list of sources for the identity specified by the parameter, which is the id of an identity with the role SOURCE_SUBADMIN. By convention, the value **me** indicates the identity id of the current user. Subadmins may only view Sources which they are able to administer; all other Sources will be filtered out when this parameter is set. If the current user is a SOURCE_SUBADMIN but fails to pass a valid value for this parameter, a 403 Forbidden is returned.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listSources: function (limit, offset, count, filters, sorters, forSubadmin, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listSources(limit, offset, count, filters, sorters, forSubadmin, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Retrieves a sample of data returned from account and group aggregation requests. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Peek source connector\'s resource objects
		         * @param {string} sourceId The ID of the Source
		         * @param {ResourceObjectsRequestBeta} resourceObjectsRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        peekResourceObjects: function (sourceId, resourceObjectsRequestBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.peekResourceObjects(sourceId, resourceObjectsRequestBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This endpoint validates that the cluster being used by the source is reachable from IdentityNow. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Ping cluster for source connector
		         * @param {string} sourceId The ID of the Source
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        pingCluster: function (sourceId, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.pingCluster(sourceId, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Replaces the native change detection configuration for the source specified by the given ID with the configuration provided in the request body.      A token with ORG_ADMIN authority is required to call this API.
		         * @summary Update Native Change Detection Configuration
		         * @param {string} id The source id
		         * @param {NativeChangeDetectionConfigBeta} nativeChangeDetectionConfigBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putNativeChangeDetectionConfig: function (id, nativeChangeDetectionConfigBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.putNativeChangeDetectionConfig(id, nativeChangeDetectionConfigBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This end-point updates the provisioning policy with the specified usage on the specified source in IdentityNow. Transforms can be used in the provisioning policy to create a new attribute that you only need during provisioning. Refer to [Transforms in Provisioning Policies](https://developer.sailpoint.com/idn/docs/transforms/guides/transforms-in-provisioning-policies) for more information. A token with API, ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		         * @summary Update Provisioning Policy by UsageType
		         * @param {string} sourceId The Source ID.
		         * @param {UsageTypeBeta} usageType The type of provisioning policy usage.  In IdentityNow, a source can support various provisioning operations. For example, when a joiner is added to a source, this may trigger both CREATE and UPDATE provisioning operations.  Each usage type is considered a provisioning policy.  A source can have any number of these provisioning policies defined.  These are the common usage types:  CREATE - This usage type relates to \&#39;Create Account Profile\&#39;, the provisioning template for the account to be created. For example, this would be used for a joiner on a source.   UPDATE - This usage type relates to \&#39;Update Account Profile\&#39;, the provisioning template for the \&#39;Update\&#39; connector operations. For example, this would be used for an attribute sync on a source. ENABLE - This usage type relates to \&#39;Enable Account Profile\&#39;, the provisioning template for the account to be enabled. For example, this could be used for a joiner on a source once the joiner\&#39;s account is created.  DISABLE - This usage type relates to \&#39;Disable Account Profile\&#39;, the provisioning template for the account to be disabled. For example, this could be used when a leaver is removed temporarily from a source.  You can use these four usage types for all your provisioning policy needs.
		         * @param {ProvisioningPolicyDtoBeta} provisioningPolicyDtoBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putProvisioningPolicy: function (sourceId, usageType, provisioningPolicyDtoBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.putProvisioningPolicy(sourceId, usageType, provisioningPolicyDtoBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API updates a source in IdentityNow, using a full object representation. In other words, the existing Source configuration is completely replaced.  Some fields are immutable and cannot be changed, such as:  * id * type * authoritative * connector * connectorClass * passwordPolicies  Attempts to modify these fields will result in a 400 error.  A token with ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		         * @summary Update Source (Full)
		         * @param {string} id The Source id
		         * @param {SourceBeta} sourceBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putSource: function (id, sourceBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.putSource(id, sourceBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Replaces the attribute synchronization configuration for the source specified by the given ID with the configuration provided in the request body. Only the \"enabled\" field of the values in the \"attributes\" array is mutable. Attempting to change other attributes or add new values to the \"attributes\" array will result in an error.      A token with ORG_ADMIN authority is required to call this API.
		         * @summary Update Attribute Sync Config
		         * @param {string} id The source id
		         * @param {AttrSyncSourceConfigBeta} attrSyncSourceConfigBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putSourceAttrSyncConfig: function (id, attrSyncSourceConfigBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.putSourceAttrSyncConfig(id, attrSyncSourceConfigBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API will completely replace an existing Schema with the submitted payload. Some fields of the Schema cannot be updated. These fields are listed below. * id * name * created * modified Any attempt to modify these fields will result in an error response with a status code of 400.
		         * @summary Update Source Schema (Full)
		         * @param {string} sourceId The Source ID.
		         * @param {string} schemaId The Schema ID.
		         * @param {SchemaBeta} schemaBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putSourceSchema: function (sourceId, schemaId, schemaBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.putSourceSchema(sourceId, schemaId, schemaBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This end-point performs attribute synchronization for a selected source. A token with ORG_ADMIN or SOURCE_ADMIN authority is required to call this API.
		         * @summary Synchronize single source attributes.
		         * @param {string} id The Source id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        syncAttributesForSource: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.syncAttributesForSource(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This endpoint performs a more detailed validation of the source\'s configuration that can take longer than the lighter weight credential validation performed by the checkConnection API. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Test configuration for source connector
		         * @param {string} sourceId The ID of the Source
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        testSourceConfiguration: function (sourceId, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.testSourceConfiguration(sourceId, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This endpoint validates that the configured credentials are valid and will properly authenticate with the source identified by the sourceId path parameter. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Check connection for source connector.
		         * @param {string} sourceId The ID of the Source.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        testSourceConnection: function (sourceId, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.testSourceConnection(sourceId, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This end-point updates a list of provisioning policies on the specified source in IdentityNow. A token with API, or ORG_ADMIN authority is required to call this API.
		         * @summary Bulk Update Provisioning Policies
		         * @param {string} sourceId The Source id.
		         * @param {Array<ProvisioningPolicyDtoBeta>} provisioningPolicyDtoBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateProvisioningPoliciesInBulk: function (sourceId, provisioningPolicyDtoBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.updateProvisioningPoliciesInBulk(sourceId, provisioningPolicyDtoBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API selectively updates an existing Provisioning Policy using a JSONPatch payload. Transforms can be used in the provisioning policy to create a new attribute that you only need during provisioning. Refer to [Transforms in Provisioning Policies](https://developer.sailpoint.com/idn/docs/transforms/guides/transforms-in-provisioning-policies) for more information. A token with API, ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		         * @summary Partial update of Provisioning Policy
		         * @param {string} sourceId The Source id.
		         * @param {UsageTypeBeta} usageType The type of provisioning policy usage.  In IdentityNow, a source can support various provisioning operations. For example, when a joiner is added to a source, this may trigger both CREATE and UPDATE provisioning operations.  Each usage type is considered a provisioning policy.  A source can have any number of these provisioning policies defined.  These are the common usage types:  CREATE - This usage type relates to \&#39;Create Account Profile\&#39;, the provisioning template for the account to be created. For example, this would be used for a joiner on a source.   UPDATE - This usage type relates to \&#39;Update Account Profile\&#39;, the provisioning template for the \&#39;Update\&#39; connector operations. For example, this would be used for an attribute sync on a source. ENABLE - This usage type relates to \&#39;Enable Account Profile\&#39;, the provisioning template for the account to be enabled. For example, this could be used for a joiner on a source once the joiner\&#39;s account is created.  DISABLE - This usage type relates to \&#39;Disable Account Profile\&#39;, the provisioning template for the account to be disabled. For example, this could be used when a leaver is removed temporarily from a source.  You can use these four usage types for all your provisioning policy needs.
		         * @param {Array<JsonPatchOperationBeta>} jsonPatchOperationBeta The JSONPatch payload used to update the schema.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateProvisioningPolicy: function (sourceId, usageType, jsonPatchOperationBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.updateProvisioningPolicy(sourceId, usageType, jsonPatchOperationBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API partially updates a source in IdentityNow, using a list of patch operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.  Some fields are immutable and cannot be changed, such as: * id * type * authoritative * created * modified * connector * connectorClass * passwordPolicies  Attempts to modify these fields will result in a 400 error.  A token with ORG_ADMIN, SOURCE_ADMIN, SOURCE_SUBADMIN, or API authority is required to call this API.
		         * @summary Update Source (Partial)
		         * @param {string} id The Source id
		         * @param {Array<JsonPatchOperationBeta>} jsonPatchOperationBeta A list of account update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard. Any password changes are submitted as plain-text and encrypted upon receipt in IdentityNow.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateSource: function (id, jsonPatchOperationBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.updateSource(id, jsonPatchOperationBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API replaces the current entitlement request configuration for a source. This source-level configuration should apply for all the entitlements in the source.  Access request to any entitlements in the source should follow this configuration unless a separate entitlement-level configuration is defined. - During access request, this source-level entitlement request configuration overrides the global organization-level configuration. - However, the entitlement-level configuration (if defined) overrides this source-level configuration.  A token with ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		         * @summary Update Source Entitlement Request Configuration
		         * @param {SourceEntitlementRequestConfigBeta} sourceEntitlementRequestConfigBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateSourceEntitlementRequestConfig: function (sourceEntitlementRequestConfigBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.updateSourceEntitlementRequestConfig(sourceEntitlementRequestConfigBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Use this API to selectively update an existing Schema using a JSONPatch payload.   The following schema fields are immutable and cannot be updated:  - id - name - created - modified   To switch an account attribute to a group entitlement, you need to have the following in place:  - `isEntitlement: true` - Must define a schema for the group and [add it to the source](https://developer.sailpoint.com/idn/api/beta/create-source-schema) before updating the `isGroup` flag.  For example, here is the `group` account attribute referencing a schema that defines the group: ```json {     \"name\": \"groups\",     \"type\": \"STRING\",     \"schema\": {         \"type\": \"CONNECTOR_SCHEMA\",         \"id\": \"2c9180887671ff8c01767b4671fc7d60\",         \"name\": \"group\"     },     \"description\": \"The groups, roles etc. that reference account group objects\",     \"isMulti\": true,     \"isEntitlement\": true,     \"isGroup\": true } ```
		         * @summary Update Source Schema (Partial)
		         * @param {string} sourceId The Source id.
		         * @param {string} schemaId The Schema id.
		         * @param {Array<JsonPatchOperationBeta>} jsonPatchOperationBeta The JSONPatch payload used to update the schema.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateSourceSchema: function (sourceId, schemaId, jsonPatchOperationBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.updateSourceSchema(sourceId, schemaId, jsonPatchOperationBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.SourcesBetaApiFp = SourcesBetaApiFp;
		/**
		 * SourcesBetaApi - factory interface
		 * @export
		 */
		var SourcesBetaApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.SourcesBetaApiFp)(configuration);
		    return {
		        /**
		         * This end-point deletes a specific source in IdentityNow. A token with ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API. All of accounts on the source will be removed first, then the source will be deleted. Actual status of task execution can be retrieved via method GET `/task-status/{id}`
		         * @summary Delete Source by ID
		         * @param {string} id The Source ID
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        _delete: function (id, axiosOptions) {
		            return localVarFp._delete(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API generates a create policy/template based on field value transforms. This API is intended for use when setting up JDBC Provisioning type sources, but it will also work on other source types. Transforms can be used in the provisioning policy to create a new attribute that you only need during provisioning. Refer to [Transforms in Provisioning Policies](https://developer.sailpoint.com/idn/docs/transforms/guides/transforms-in-provisioning-policies) for more information. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Create Provisioning Policy
		         * @param {string} sourceId The Source id
		         * @param {ProvisioningPolicyDtoBeta} provisioningPolicyDtoBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createProvisioningPolicy: function (sourceId, provisioningPolicyDtoBeta, axiosOptions) {
		            return localVarFp.createProvisioningPolicy(sourceId, provisioningPolicyDtoBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This creates a specific source with a full source JSON representation. Any passwords are submitted as plain-text and encrypted upon receipt in IdentityNow. A token with ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		         * @summary Creates a source in IdentityNow.
		         * @param {SourceBeta} sourceBeta
		         * @param {boolean} [provisionAsCsv] If this parameter is &#x60;true&#x60;, it configures the source as a Delimited File (CSV) source. Setting this to &#x60;true&#x60; will automatically set the &#x60;type&#x60; of the source to &#x60;DelimitedFile&#x60;.  You must use this query parameter to create a Delimited File source as you would in the UI.  If you don\&#39;t set this query parameter and you attempt to set the &#x60;type&#x60; attribute directly, the request won\&#39;t correctly generate the source.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createSource: function (sourceBeta, provisionAsCsv, axiosOptions) {
		            return localVarFp.createSource(sourceBeta, provisionAsCsv, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         *
		         * @summary Creates a new Schema on the specified Source in IdentityNow.
		         * @param {string} sourceId The Source id.
		         * @param {SchemaBeta} schemaBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createSourceSchema: function (sourceId, schemaBeta, axiosOptions) {
		            return localVarFp.createSourceSchema(sourceId, schemaBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Deletes the native change detection configuration for the source specified by the given ID. A token with API, or ORG_ADMIN authority is required to call this API.
		         * @summary Delete Native Change Detection Configuration
		         * @param {string} id The source id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteNativeChangeDetectionConfig: function (id, axiosOptions) {
		            return localVarFp.deleteNativeChangeDetectionConfig(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Deletes the provisioning policy with the specified usage on an application. A token with API, or ORG_ADMIN authority is required to call this API.
		         * @summary Delete Provisioning Policy by UsageType
		         * @param {string} sourceId The Source ID.
		         * @param {UsageTypeBeta} usageType The type of provisioning policy usage.  In IdentityNow, a source can support various provisioning operations. For example, when a joiner is added to a source, this may trigger both CREATE and UPDATE provisioning operations.  Each usage type is considered a provisioning policy.  A source can have any number of these provisioning policies defined.  These are the common usage types:  CREATE - This usage type relates to \&#39;Create Account Profile\&#39;, the provisioning template for the account to be created. For example, this would be used for a joiner on a source.   UPDATE - This usage type relates to \&#39;Update Account Profile\&#39;, the provisioning template for the \&#39;Update\&#39; connector operations. For example, this would be used for an attribute sync on a source. ENABLE - This usage type relates to \&#39;Enable Account Profile\&#39;, the provisioning template for the account to be enabled. For example, this could be used for a joiner on a source once the joiner\&#39;s account is created.  DISABLE - This usage type relates to \&#39;Disable Account Profile\&#39;, the provisioning template for the account to be disabled. For example, this could be used when a leaver is removed temporarily from a source.  You can use these four usage types for all your provisioning policy needs.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteProvisioningPolicy: function (sourceId, usageType, axiosOptions) {
		            return localVarFp.deleteProvisioningPolicy(sourceId, usageType, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         *
		         * @summary Delete Source Schema by ID
		         * @param {string} sourceId The Source ID.
		         * @param {string} schemaId The Schema ID.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteSourceSchema: function (sourceId, schemaId, axiosOptions) {
		            return localVarFp.deleteSourceSchema(sourceId, schemaId, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API returns the existing native change detection configuration for a source specified by the given ID. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Native Change Detection Configuration
		         * @param {string} id The source id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getNativeChangeDetectionConfig: function (id, axiosOptions) {
		            return localVarFp.getNativeChangeDetectionConfig(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This end-point retrieves the ProvisioningPolicy with the specified usage on the specified Source in IdentityNow. A token with API, ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		         * @summary Get Provisioning Policy by UsageType
		         * @param {string} sourceId The Source ID.
		         * @param {UsageTypeBeta} usageType The type of provisioning policy usage.  In IdentityNow, a source can support various provisioning operations. For example, when a joiner is added to a source, this may trigger both CREATE and UPDATE provisioning operations.  Each usage type is considered a provisioning policy.  A source can have any number of these provisioning policies defined.  These are the common usage types:  CREATE - This usage type relates to \&#39;Create Account Profile\&#39;, the provisioning template for the account to be created. For example, this would be used for a joiner on a source.   UPDATE - This usage type relates to \&#39;Update Account Profile\&#39;, the provisioning template for the \&#39;Update\&#39; connector operations. For example, this would be used for an attribute sync on a source. ENABLE - This usage type relates to \&#39;Enable Account Profile\&#39;, the provisioning template for the account to be enabled. For example, this could be used for a joiner on a source once the joiner\&#39;s account is created.  DISABLE - This usage type relates to \&#39;Disable Account Profile\&#39;, the provisioning template for the account to be disabled. For example, this could be used when a leaver is removed temporarily from a source.  You can use these four usage types for all your provisioning policy needs.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getProvisioningPolicy: function (sourceId, usageType, axiosOptions) {
		            return localVarFp.getProvisioningPolicy(sourceId, usageType, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This end-point gets a specific source in IdentityNow. A token with ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		         * @summary Get Source by ID
		         * @param {string} id The Source ID
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getSource: function (id, axiosOptions) {
		            return localVarFp.getSource(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         *
		         * @summary Downloads source accounts schema template
		         * @param {string} id The Source id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getSourceAccountsSchema: function (id, axiosOptions) {
		            return localVarFp.getSourceAccountsSchema(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API returns the existing attribute synchronization configuration for a source specified by the given ID. The response contains all attributes, regardless of whether they enabled or not. A token with ORG_ADMIN or HELPDESK authority is required to call this API.
		         * @summary Attribute Sync Config
		         * @param {string} id The source id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getSourceAttrSyncConfig: function (id, axiosOptions) {
		            return localVarFp.getSourceAttrSyncConfig(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Looks up and returns the source config for the requested source id after populating the source config values and applying language translations. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Gets source config with language translations
		         * @param {string} id The Source id
		         * @param {'de' | 'false' | 'fi' | 'sv' | 'ru' | 'pt' | 'ko' | 'zh-TW' | 'en' | 'it' | 'fr' | 'zh-CN' | 'hu' | 'es' | 'cs' | 'ja' | 'pl' | 'da' | 'nl'} [locale] The locale to apply to the config. If no viable locale is given, it will default to \&quot;en\&quot;
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getSourceConfig: function (id, locale, axiosOptions) {
		            return localVarFp.getSourceConfig(id, locale, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API gets the current entitlement request configuration for a source. This source-level configuration should apply for all the entitlements in the source.  Access request to any entitlements in the source should follow this configuration unless a separate entitlement-level configuration is defined. - During access request, this source-level entitlement request configuration overrides the global organization-level configuration. - However, the entitlement-level configuration (if defined) overrides this source-level configuration.  A token with ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		         * @summary Get Source Entitlement Request Configuration
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getSourceEntitlementRequestConfig: function (axiosOptions) {
		            return localVarFp.getSourceEntitlementRequestConfig(axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         *
		         * @summary Downloads source entitlements schema template
		         * @param {string} id The Source id
		         * @param {string} [schemaName] Name of entitlement schema
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getSourceEntitlementsSchema: function (id, schemaName, axiosOptions) {
		            return localVarFp.getSourceEntitlementsSchema(id, schemaName, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Get the Source Schema by ID in IdentityNow.
		         * @summary Get Source Schema by ID
		         * @param {string} sourceId The Source ID.
		         * @param {string} schemaId The Schema ID.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getSourceSchema: function (sourceId, schemaId, axiosOptions) {
		            return localVarFp.getSourceSchema(sourceId, schemaId, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API uploads a source schema template file to configure a source\'s account attributes.
		         * @summary Uploads source accounts schema template
		         * @param {string} id The Source id
		         * @param {any} [file]
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        importSourceAccountsSchema: function (id, file, axiosOptions) {
		            return localVarFp.importSourceAccountsSchema(id, file, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This uploads a supplemental source connector file (like jdbc driver jars) to a source\'s S3 bucket. This also sends ETS and Audit events. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Upload connector file to source
		         * @param {string} sourceId The Source id
		         * @param {any} [file]
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        importSourceConnectorFile: function (sourceId, file, axiosOptions) {
		            return localVarFp.importSourceConnectorFile(sourceId, file, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API uploads a source schema template file to configure a source\'s entitlement attributes.
		         * @summary Uploads source entitlements schema template
		         * @param {string} id The Source id
		         * @param {string} [schemaName] Name of entitlement schema
		         * @param {any} [file]
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        importSourceEntitlementsSchema: function (id, schemaName, file, axiosOptions) {
		            return localVarFp.importSourceEntitlementsSchema(id, schemaName, file, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This end-point lists all the ProvisioningPolicies in IdentityNow. A token with API, or ORG_ADMIN authority is required to call this API.
		         * @summary Lists ProvisioningPolicies
		         * @param {string} sourceId The Source id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listProvisioningPolicies: function (sourceId, axiosOptions) {
		            return localVarFp.listProvisioningPolicies(sourceId, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         *
		         * @summary Lists the Schemas that exist on the specified Source in IdentityNow.
		         * @param {string} sourceId The Source id.
		         * @param {string} [includeTypes] If set to \&#39;group\&#39;, then the account schema is filtered and only group schemas are returned. Only a value of \&#39;group\&#39; is recognized.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listSourceSchemas: function (sourceId, includeTypes, axiosOptions) {
		            return localVarFp.listSourceSchemas(sourceId, includeTypes, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This end-point lists all the sources in IdentityNow.  A token with ORG_ADMIN, SOURCE_ADMIN, SOURCE_SUBADMIN, or ROLE_SUBADMIN authority is required to call this API.
		         * @summary Lists all sources in IdentityNow.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in, ge, gt, le, lt, ne, isnull, sw*  **name**: *co, eq, in, sw, ge, gt, ne, isnull*  **type**: *eq, in, ge, gt, ne, isnull, sw*  **owner.id**: *eq, in, ge, gt, le, lt, ne, isnull, sw*  **features**: *ca, co*  **created**: *eq*  **modified**: *eq*  **managementWorkgroup.id**: *eq, ge, gt, in, le, lt, ne, isnull, sw*  **description**: *eq, sw*  **authoritative**: *eq, ne, isnull*  **healthy**: *isnull*  **status**: *eq, in, ge, gt, le, lt, ne, isnull, sw*  **connectionType**: *eq, ge, gt, in, le, lt, ne, isnull, sw*  **connectorName**: *eq, ge, gt, in, ne, isnull, sw*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **type, created, modified, name, owner.name, healthy, status, id, description, owner.id, accountCorrelationConfig.id, accountCorrelationConfig.name, managerCorrelationRule.type, managerCorrelationRule.id, managerCorrelationRule.name, authoritative, managementWorkgroup.id, connectorName, connectionType**
		         * @param {string} [forSubadmin] Filter the returned list of sources for the identity specified by the parameter, which is the id of an identity with the role SOURCE_SUBADMIN. By convention, the value **me** indicates the identity id of the current user. Subadmins may only view Sources which they are able to administer; all other Sources will be filtered out when this parameter is set. If the current user is a SOURCE_SUBADMIN but fails to pass a valid value for this parameter, a 403 Forbidden is returned.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listSources: function (limit, offset, count, filters, sorters, forSubadmin, axiosOptions) {
		            return localVarFp.listSources(limit, offset, count, filters, sorters, forSubadmin, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Retrieves a sample of data returned from account and group aggregation requests. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Peek source connector\'s resource objects
		         * @param {string} sourceId The ID of the Source
		         * @param {ResourceObjectsRequestBeta} resourceObjectsRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        peekResourceObjects: function (sourceId, resourceObjectsRequestBeta, axiosOptions) {
		            return localVarFp.peekResourceObjects(sourceId, resourceObjectsRequestBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This endpoint validates that the cluster being used by the source is reachable from IdentityNow. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Ping cluster for source connector
		         * @param {string} sourceId The ID of the Source
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        pingCluster: function (sourceId, axiosOptions) {
		            return localVarFp.pingCluster(sourceId, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Replaces the native change detection configuration for the source specified by the given ID with the configuration provided in the request body.      A token with ORG_ADMIN authority is required to call this API.
		         * @summary Update Native Change Detection Configuration
		         * @param {string} id The source id
		         * @param {NativeChangeDetectionConfigBeta} nativeChangeDetectionConfigBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putNativeChangeDetectionConfig: function (id, nativeChangeDetectionConfigBeta, axiosOptions) {
		            return localVarFp.putNativeChangeDetectionConfig(id, nativeChangeDetectionConfigBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This end-point updates the provisioning policy with the specified usage on the specified source in IdentityNow. Transforms can be used in the provisioning policy to create a new attribute that you only need during provisioning. Refer to [Transforms in Provisioning Policies](https://developer.sailpoint.com/idn/docs/transforms/guides/transforms-in-provisioning-policies) for more information. A token with API, ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		         * @summary Update Provisioning Policy by UsageType
		         * @param {string} sourceId The Source ID.
		         * @param {UsageTypeBeta} usageType The type of provisioning policy usage.  In IdentityNow, a source can support various provisioning operations. For example, when a joiner is added to a source, this may trigger both CREATE and UPDATE provisioning operations.  Each usage type is considered a provisioning policy.  A source can have any number of these provisioning policies defined.  These are the common usage types:  CREATE - This usage type relates to \&#39;Create Account Profile\&#39;, the provisioning template for the account to be created. For example, this would be used for a joiner on a source.   UPDATE - This usage type relates to \&#39;Update Account Profile\&#39;, the provisioning template for the \&#39;Update\&#39; connector operations. For example, this would be used for an attribute sync on a source. ENABLE - This usage type relates to \&#39;Enable Account Profile\&#39;, the provisioning template for the account to be enabled. For example, this could be used for a joiner on a source once the joiner\&#39;s account is created.  DISABLE - This usage type relates to \&#39;Disable Account Profile\&#39;, the provisioning template for the account to be disabled. For example, this could be used when a leaver is removed temporarily from a source.  You can use these four usage types for all your provisioning policy needs.
		         * @param {ProvisioningPolicyDtoBeta} provisioningPolicyDtoBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putProvisioningPolicy: function (sourceId, usageType, provisioningPolicyDtoBeta, axiosOptions) {
		            return localVarFp.putProvisioningPolicy(sourceId, usageType, provisioningPolicyDtoBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API updates a source in IdentityNow, using a full object representation. In other words, the existing Source configuration is completely replaced.  Some fields are immutable and cannot be changed, such as:  * id * type * authoritative * connector * connectorClass * passwordPolicies  Attempts to modify these fields will result in a 400 error.  A token with ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		         * @summary Update Source (Full)
		         * @param {string} id The Source id
		         * @param {SourceBeta} sourceBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putSource: function (id, sourceBeta, axiosOptions) {
		            return localVarFp.putSource(id, sourceBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Replaces the attribute synchronization configuration for the source specified by the given ID with the configuration provided in the request body. Only the \"enabled\" field of the values in the \"attributes\" array is mutable. Attempting to change other attributes or add new values to the \"attributes\" array will result in an error.      A token with ORG_ADMIN authority is required to call this API.
		         * @summary Update Attribute Sync Config
		         * @param {string} id The source id
		         * @param {AttrSyncSourceConfigBeta} attrSyncSourceConfigBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putSourceAttrSyncConfig: function (id, attrSyncSourceConfigBeta, axiosOptions) {
		            return localVarFp.putSourceAttrSyncConfig(id, attrSyncSourceConfigBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API will completely replace an existing Schema with the submitted payload. Some fields of the Schema cannot be updated. These fields are listed below. * id * name * created * modified Any attempt to modify these fields will result in an error response with a status code of 400.
		         * @summary Update Source Schema (Full)
		         * @param {string} sourceId The Source ID.
		         * @param {string} schemaId The Schema ID.
		         * @param {SchemaBeta} schemaBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putSourceSchema: function (sourceId, schemaId, schemaBeta, axiosOptions) {
		            return localVarFp.putSourceSchema(sourceId, schemaId, schemaBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This end-point performs attribute synchronization for a selected source. A token with ORG_ADMIN or SOURCE_ADMIN authority is required to call this API.
		         * @summary Synchronize single source attributes.
		         * @param {string} id The Source id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        syncAttributesForSource: function (id, axiosOptions) {
		            return localVarFp.syncAttributesForSource(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This endpoint performs a more detailed validation of the source\'s configuration that can take longer than the lighter weight credential validation performed by the checkConnection API. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Test configuration for source connector
		         * @param {string} sourceId The ID of the Source
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        testSourceConfiguration: function (sourceId, axiosOptions) {
		            return localVarFp.testSourceConfiguration(sourceId, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This endpoint validates that the configured credentials are valid and will properly authenticate with the source identified by the sourceId path parameter. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Check connection for source connector.
		         * @param {string} sourceId The ID of the Source.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        testSourceConnection: function (sourceId, axiosOptions) {
		            return localVarFp.testSourceConnection(sourceId, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This end-point updates a list of provisioning policies on the specified source in IdentityNow. A token with API, or ORG_ADMIN authority is required to call this API.
		         * @summary Bulk Update Provisioning Policies
		         * @param {string} sourceId The Source id.
		         * @param {Array<ProvisioningPolicyDtoBeta>} provisioningPolicyDtoBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateProvisioningPoliciesInBulk: function (sourceId, provisioningPolicyDtoBeta, axiosOptions) {
		            return localVarFp.updateProvisioningPoliciesInBulk(sourceId, provisioningPolicyDtoBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API selectively updates an existing Provisioning Policy using a JSONPatch payload. Transforms can be used in the provisioning policy to create a new attribute that you only need during provisioning. Refer to [Transforms in Provisioning Policies](https://developer.sailpoint.com/idn/docs/transforms/guides/transforms-in-provisioning-policies) for more information. A token with API, ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		         * @summary Partial update of Provisioning Policy
		         * @param {string} sourceId The Source id.
		         * @param {UsageTypeBeta} usageType The type of provisioning policy usage.  In IdentityNow, a source can support various provisioning operations. For example, when a joiner is added to a source, this may trigger both CREATE and UPDATE provisioning operations.  Each usage type is considered a provisioning policy.  A source can have any number of these provisioning policies defined.  These are the common usage types:  CREATE - This usage type relates to \&#39;Create Account Profile\&#39;, the provisioning template for the account to be created. For example, this would be used for a joiner on a source.   UPDATE - This usage type relates to \&#39;Update Account Profile\&#39;, the provisioning template for the \&#39;Update\&#39; connector operations. For example, this would be used for an attribute sync on a source. ENABLE - This usage type relates to \&#39;Enable Account Profile\&#39;, the provisioning template for the account to be enabled. For example, this could be used for a joiner on a source once the joiner\&#39;s account is created.  DISABLE - This usage type relates to \&#39;Disable Account Profile\&#39;, the provisioning template for the account to be disabled. For example, this could be used when a leaver is removed temporarily from a source.  You can use these four usage types for all your provisioning policy needs.
		         * @param {Array<JsonPatchOperationBeta>} jsonPatchOperationBeta The JSONPatch payload used to update the schema.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateProvisioningPolicy: function (sourceId, usageType, jsonPatchOperationBeta, axiosOptions) {
		            return localVarFp.updateProvisioningPolicy(sourceId, usageType, jsonPatchOperationBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API partially updates a source in IdentityNow, using a list of patch operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.  Some fields are immutable and cannot be changed, such as: * id * type * authoritative * created * modified * connector * connectorClass * passwordPolicies  Attempts to modify these fields will result in a 400 error.  A token with ORG_ADMIN, SOURCE_ADMIN, SOURCE_SUBADMIN, or API authority is required to call this API.
		         * @summary Update Source (Partial)
		         * @param {string} id The Source id
		         * @param {Array<JsonPatchOperationBeta>} jsonPatchOperationBeta A list of account update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard. Any password changes are submitted as plain-text and encrypted upon receipt in IdentityNow.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateSource: function (id, jsonPatchOperationBeta, axiosOptions) {
		            return localVarFp.updateSource(id, jsonPatchOperationBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API replaces the current entitlement request configuration for a source. This source-level configuration should apply for all the entitlements in the source.  Access request to any entitlements in the source should follow this configuration unless a separate entitlement-level configuration is defined. - During access request, this source-level entitlement request configuration overrides the global organization-level configuration. - However, the entitlement-level configuration (if defined) overrides this source-level configuration.  A token with ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		         * @summary Update Source Entitlement Request Configuration
		         * @param {SourceEntitlementRequestConfigBeta} sourceEntitlementRequestConfigBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateSourceEntitlementRequestConfig: function (sourceEntitlementRequestConfigBeta, axiosOptions) {
		            return localVarFp.updateSourceEntitlementRequestConfig(sourceEntitlementRequestConfigBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Use this API to selectively update an existing Schema using a JSONPatch payload.   The following schema fields are immutable and cannot be updated:  - id - name - created - modified   To switch an account attribute to a group entitlement, you need to have the following in place:  - `isEntitlement: true` - Must define a schema for the group and [add it to the source](https://developer.sailpoint.com/idn/api/beta/create-source-schema) before updating the `isGroup` flag.  For example, here is the `group` account attribute referencing a schema that defines the group: ```json {     \"name\": \"groups\",     \"type\": \"STRING\",     \"schema\": {         \"type\": \"CONNECTOR_SCHEMA\",         \"id\": \"2c9180887671ff8c01767b4671fc7d60\",         \"name\": \"group\"     },     \"description\": \"The groups, roles etc. that reference account group objects\",     \"isMulti\": true,     \"isEntitlement\": true,     \"isGroup\": true } ```
		         * @summary Update Source Schema (Partial)
		         * @param {string} sourceId The Source id.
		         * @param {string} schemaId The Schema id.
		         * @param {Array<JsonPatchOperationBeta>} jsonPatchOperationBeta The JSONPatch payload used to update the schema.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateSourceSchema: function (sourceId, schemaId, jsonPatchOperationBeta, axiosOptions) {
		            return localVarFp.updateSourceSchema(sourceId, schemaId, jsonPatchOperationBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.SourcesBetaApiFactory = SourcesBetaApiFactory;
		/**
		 * SourcesBetaApi - object-oriented interface
		 * @export
		 * @class SourcesBetaApi
		 * @extends {BaseAPI}
		 */
		var SourcesBetaApi = /** @class */ (function (_super) {
		    __extends(SourcesBetaApi, _super);
		    function SourcesBetaApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * This end-point deletes a specific source in IdentityNow. A token with ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API. All of accounts on the source will be removed first, then the source will be deleted. Actual status of task execution can be retrieved via method GET `/task-status/{id}`
		     * @summary Delete Source by ID
		     * @param {SourcesBetaApiDeleteRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SourcesBetaApi
		     */
		    SourcesBetaApi.prototype._delete = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SourcesBetaApiFp)(this.configuration)._delete(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API generates a create policy/template based on field value transforms. This API is intended for use when setting up JDBC Provisioning type sources, but it will also work on other source types. Transforms can be used in the provisioning policy to create a new attribute that you only need during provisioning. Refer to [Transforms in Provisioning Policies](https://developer.sailpoint.com/idn/docs/transforms/guides/transforms-in-provisioning-policies) for more information. A token with ORG_ADMIN authority is required to call this API.
		     * @summary Create Provisioning Policy
		     * @param {SourcesBetaApiCreateProvisioningPolicyRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SourcesBetaApi
		     */
		    SourcesBetaApi.prototype.createProvisioningPolicy = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SourcesBetaApiFp)(this.configuration).createProvisioningPolicy(requestParameters.sourceId, requestParameters.provisioningPolicyDtoBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This creates a specific source with a full source JSON representation. Any passwords are submitted as plain-text and encrypted upon receipt in IdentityNow. A token with ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		     * @summary Creates a source in IdentityNow.
		     * @param {SourcesBetaApiCreateSourceRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SourcesBetaApi
		     */
		    SourcesBetaApi.prototype.createSource = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SourcesBetaApiFp)(this.configuration).createSource(requestParameters.sourceBeta, requestParameters.provisionAsCsv, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     *
		     * @summary Creates a new Schema on the specified Source in IdentityNow.
		     * @param {SourcesBetaApiCreateSourceSchemaRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SourcesBetaApi
		     */
		    SourcesBetaApi.prototype.createSourceSchema = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SourcesBetaApiFp)(this.configuration).createSourceSchema(requestParameters.sourceId, requestParameters.schemaBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Deletes the native change detection configuration for the source specified by the given ID. A token with API, or ORG_ADMIN authority is required to call this API.
		     * @summary Delete Native Change Detection Configuration
		     * @param {SourcesBetaApiDeleteNativeChangeDetectionConfigRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SourcesBetaApi
		     */
		    SourcesBetaApi.prototype.deleteNativeChangeDetectionConfig = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SourcesBetaApiFp)(this.configuration).deleteNativeChangeDetectionConfig(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Deletes the provisioning policy with the specified usage on an application. A token with API, or ORG_ADMIN authority is required to call this API.
		     * @summary Delete Provisioning Policy by UsageType
		     * @param {SourcesBetaApiDeleteProvisioningPolicyRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SourcesBetaApi
		     */
		    SourcesBetaApi.prototype.deleteProvisioningPolicy = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SourcesBetaApiFp)(this.configuration).deleteProvisioningPolicy(requestParameters.sourceId, requestParameters.usageType, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     *
		     * @summary Delete Source Schema by ID
		     * @param {SourcesBetaApiDeleteSourceSchemaRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SourcesBetaApi
		     */
		    SourcesBetaApi.prototype.deleteSourceSchema = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SourcesBetaApiFp)(this.configuration).deleteSourceSchema(requestParameters.sourceId, requestParameters.schemaId, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API returns the existing native change detection configuration for a source specified by the given ID. A token with ORG_ADMIN authority is required to call this API.
		     * @summary Native Change Detection Configuration
		     * @param {SourcesBetaApiGetNativeChangeDetectionConfigRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SourcesBetaApi
		     */
		    SourcesBetaApi.prototype.getNativeChangeDetectionConfig = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SourcesBetaApiFp)(this.configuration).getNativeChangeDetectionConfig(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This end-point retrieves the ProvisioningPolicy with the specified usage on the specified Source in IdentityNow. A token with API, ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		     * @summary Get Provisioning Policy by UsageType
		     * @param {SourcesBetaApiGetProvisioningPolicyRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SourcesBetaApi
		     */
		    SourcesBetaApi.prototype.getProvisioningPolicy = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SourcesBetaApiFp)(this.configuration).getProvisioningPolicy(requestParameters.sourceId, requestParameters.usageType, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This end-point gets a specific source in IdentityNow. A token with ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		     * @summary Get Source by ID
		     * @param {SourcesBetaApiGetSourceRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SourcesBetaApi
		     */
		    SourcesBetaApi.prototype.getSource = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SourcesBetaApiFp)(this.configuration).getSource(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     *
		     * @summary Downloads source accounts schema template
		     * @param {SourcesBetaApiGetSourceAccountsSchemaRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SourcesBetaApi
		     */
		    SourcesBetaApi.prototype.getSourceAccountsSchema = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SourcesBetaApiFp)(this.configuration).getSourceAccountsSchema(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API returns the existing attribute synchronization configuration for a source specified by the given ID. The response contains all attributes, regardless of whether they enabled or not. A token with ORG_ADMIN or HELPDESK authority is required to call this API.
		     * @summary Attribute Sync Config
		     * @param {SourcesBetaApiGetSourceAttrSyncConfigRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SourcesBetaApi
		     */
		    SourcesBetaApi.prototype.getSourceAttrSyncConfig = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SourcesBetaApiFp)(this.configuration).getSourceAttrSyncConfig(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Looks up and returns the source config for the requested source id after populating the source config values and applying language translations. A token with ORG_ADMIN authority is required to call this API.
		     * @summary Gets source config with language translations
		     * @param {SourcesBetaApiGetSourceConfigRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SourcesBetaApi
		     */
		    SourcesBetaApi.prototype.getSourceConfig = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SourcesBetaApiFp)(this.configuration).getSourceConfig(requestParameters.id, requestParameters.locale, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API gets the current entitlement request configuration for a source. This source-level configuration should apply for all the entitlements in the source.  Access request to any entitlements in the source should follow this configuration unless a separate entitlement-level configuration is defined. - During access request, this source-level entitlement request configuration overrides the global organization-level configuration. - However, the entitlement-level configuration (if defined) overrides this source-level configuration.  A token with ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		     * @summary Get Source Entitlement Request Configuration
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SourcesBetaApi
		     */
		    SourcesBetaApi.prototype.getSourceEntitlementRequestConfig = function (axiosOptions) {
		        var _this = this;
		        return (0, exports.SourcesBetaApiFp)(this.configuration).getSourceEntitlementRequestConfig(axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     *
		     * @summary Downloads source entitlements schema template
		     * @param {SourcesBetaApiGetSourceEntitlementsSchemaRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SourcesBetaApi
		     */
		    SourcesBetaApi.prototype.getSourceEntitlementsSchema = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SourcesBetaApiFp)(this.configuration).getSourceEntitlementsSchema(requestParameters.id, requestParameters.schemaName, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Get the Source Schema by ID in IdentityNow.
		     * @summary Get Source Schema by ID
		     * @param {SourcesBetaApiGetSourceSchemaRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SourcesBetaApi
		     */
		    SourcesBetaApi.prototype.getSourceSchema = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SourcesBetaApiFp)(this.configuration).getSourceSchema(requestParameters.sourceId, requestParameters.schemaId, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API uploads a source schema template file to configure a source\'s account attributes.
		     * @summary Uploads source accounts schema template
		     * @param {SourcesBetaApiImportSourceAccountsSchemaRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SourcesBetaApi
		     */
		    SourcesBetaApi.prototype.importSourceAccountsSchema = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SourcesBetaApiFp)(this.configuration).importSourceAccountsSchema(requestParameters.id, requestParameters.file, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This uploads a supplemental source connector file (like jdbc driver jars) to a source\'s S3 bucket. This also sends ETS and Audit events. A token with ORG_ADMIN authority is required to call this API.
		     * @summary Upload connector file to source
		     * @param {SourcesBetaApiImportSourceConnectorFileRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SourcesBetaApi
		     */
		    SourcesBetaApi.prototype.importSourceConnectorFile = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SourcesBetaApiFp)(this.configuration).importSourceConnectorFile(requestParameters.sourceId, requestParameters.file, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API uploads a source schema template file to configure a source\'s entitlement attributes.
		     * @summary Uploads source entitlements schema template
		     * @param {SourcesBetaApiImportSourceEntitlementsSchemaRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SourcesBetaApi
		     */
		    SourcesBetaApi.prototype.importSourceEntitlementsSchema = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SourcesBetaApiFp)(this.configuration).importSourceEntitlementsSchema(requestParameters.id, requestParameters.schemaName, requestParameters.file, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This end-point lists all the ProvisioningPolicies in IdentityNow. A token with API, or ORG_ADMIN authority is required to call this API.
		     * @summary Lists ProvisioningPolicies
		     * @param {SourcesBetaApiListProvisioningPoliciesRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SourcesBetaApi
		     */
		    SourcesBetaApi.prototype.listProvisioningPolicies = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SourcesBetaApiFp)(this.configuration).listProvisioningPolicies(requestParameters.sourceId, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     *
		     * @summary Lists the Schemas that exist on the specified Source in IdentityNow.
		     * @param {SourcesBetaApiListSourceSchemasRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SourcesBetaApi
		     */
		    SourcesBetaApi.prototype.listSourceSchemas = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SourcesBetaApiFp)(this.configuration).listSourceSchemas(requestParameters.sourceId, requestParameters.includeTypes, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This end-point lists all the sources in IdentityNow.  A token with ORG_ADMIN, SOURCE_ADMIN, SOURCE_SUBADMIN, or ROLE_SUBADMIN authority is required to call this API.
		     * @summary Lists all sources in IdentityNow.
		     * @param {SourcesBetaApiListSourcesRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SourcesBetaApi
		     */
		    SourcesBetaApi.prototype.listSources = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.SourcesBetaApiFp)(this.configuration).listSources(requestParameters.limit, requestParameters.offset, requestParameters.count, requestParameters.filters, requestParameters.sorters, requestParameters.forSubadmin, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Retrieves a sample of data returned from account and group aggregation requests. A token with ORG_ADMIN authority is required to call this API.
		     * @summary Peek source connector\'s resource objects
		     * @param {SourcesBetaApiPeekResourceObjectsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SourcesBetaApi
		     */
		    SourcesBetaApi.prototype.peekResourceObjects = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SourcesBetaApiFp)(this.configuration).peekResourceObjects(requestParameters.sourceId, requestParameters.resourceObjectsRequestBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This endpoint validates that the cluster being used by the source is reachable from IdentityNow. A token with ORG_ADMIN authority is required to call this API.
		     * @summary Ping cluster for source connector
		     * @param {SourcesBetaApiPingClusterRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SourcesBetaApi
		     */
		    SourcesBetaApi.prototype.pingCluster = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SourcesBetaApiFp)(this.configuration).pingCluster(requestParameters.sourceId, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Replaces the native change detection configuration for the source specified by the given ID with the configuration provided in the request body.      A token with ORG_ADMIN authority is required to call this API.
		     * @summary Update Native Change Detection Configuration
		     * @param {SourcesBetaApiPutNativeChangeDetectionConfigRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SourcesBetaApi
		     */
		    SourcesBetaApi.prototype.putNativeChangeDetectionConfig = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SourcesBetaApiFp)(this.configuration).putNativeChangeDetectionConfig(requestParameters.id, requestParameters.nativeChangeDetectionConfigBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This end-point updates the provisioning policy with the specified usage on the specified source in IdentityNow. Transforms can be used in the provisioning policy to create a new attribute that you only need during provisioning. Refer to [Transforms in Provisioning Policies](https://developer.sailpoint.com/idn/docs/transforms/guides/transforms-in-provisioning-policies) for more information. A token with API, ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		     * @summary Update Provisioning Policy by UsageType
		     * @param {SourcesBetaApiPutProvisioningPolicyRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SourcesBetaApi
		     */
		    SourcesBetaApi.prototype.putProvisioningPolicy = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SourcesBetaApiFp)(this.configuration).putProvisioningPolicy(requestParameters.sourceId, requestParameters.usageType, requestParameters.provisioningPolicyDtoBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API updates a source in IdentityNow, using a full object representation. In other words, the existing Source configuration is completely replaced.  Some fields are immutable and cannot be changed, such as:  * id * type * authoritative * connector * connectorClass * passwordPolicies  Attempts to modify these fields will result in a 400 error.  A token with ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		     * @summary Update Source (Full)
		     * @param {SourcesBetaApiPutSourceRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SourcesBetaApi
		     */
		    SourcesBetaApi.prototype.putSource = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SourcesBetaApiFp)(this.configuration).putSource(requestParameters.id, requestParameters.sourceBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Replaces the attribute synchronization configuration for the source specified by the given ID with the configuration provided in the request body. Only the \"enabled\" field of the values in the \"attributes\" array is mutable. Attempting to change other attributes or add new values to the \"attributes\" array will result in an error.      A token with ORG_ADMIN authority is required to call this API.
		     * @summary Update Attribute Sync Config
		     * @param {SourcesBetaApiPutSourceAttrSyncConfigRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SourcesBetaApi
		     */
		    SourcesBetaApi.prototype.putSourceAttrSyncConfig = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SourcesBetaApiFp)(this.configuration).putSourceAttrSyncConfig(requestParameters.id, requestParameters.attrSyncSourceConfigBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API will completely replace an existing Schema with the submitted payload. Some fields of the Schema cannot be updated. These fields are listed below. * id * name * created * modified Any attempt to modify these fields will result in an error response with a status code of 400.
		     * @summary Update Source Schema (Full)
		     * @param {SourcesBetaApiPutSourceSchemaRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SourcesBetaApi
		     */
		    SourcesBetaApi.prototype.putSourceSchema = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SourcesBetaApiFp)(this.configuration).putSourceSchema(requestParameters.sourceId, requestParameters.schemaId, requestParameters.schemaBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This end-point performs attribute synchronization for a selected source. A token with ORG_ADMIN or SOURCE_ADMIN authority is required to call this API.
		     * @summary Synchronize single source attributes.
		     * @param {SourcesBetaApiSyncAttributesForSourceRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SourcesBetaApi
		     */
		    SourcesBetaApi.prototype.syncAttributesForSource = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SourcesBetaApiFp)(this.configuration).syncAttributesForSource(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This endpoint performs a more detailed validation of the source\'s configuration that can take longer than the lighter weight credential validation performed by the checkConnection API. A token with ORG_ADMIN authority is required to call this API.
		     * @summary Test configuration for source connector
		     * @param {SourcesBetaApiTestSourceConfigurationRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SourcesBetaApi
		     */
		    SourcesBetaApi.prototype.testSourceConfiguration = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SourcesBetaApiFp)(this.configuration).testSourceConfiguration(requestParameters.sourceId, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This endpoint validates that the configured credentials are valid and will properly authenticate with the source identified by the sourceId path parameter. A token with ORG_ADMIN authority is required to call this API.
		     * @summary Check connection for source connector.
		     * @param {SourcesBetaApiTestSourceConnectionRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SourcesBetaApi
		     */
		    SourcesBetaApi.prototype.testSourceConnection = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SourcesBetaApiFp)(this.configuration).testSourceConnection(requestParameters.sourceId, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This end-point updates a list of provisioning policies on the specified source in IdentityNow. A token with API, or ORG_ADMIN authority is required to call this API.
		     * @summary Bulk Update Provisioning Policies
		     * @param {SourcesBetaApiUpdateProvisioningPoliciesInBulkRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SourcesBetaApi
		     */
		    SourcesBetaApi.prototype.updateProvisioningPoliciesInBulk = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SourcesBetaApiFp)(this.configuration).updateProvisioningPoliciesInBulk(requestParameters.sourceId, requestParameters.provisioningPolicyDtoBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API selectively updates an existing Provisioning Policy using a JSONPatch payload. Transforms can be used in the provisioning policy to create a new attribute that you only need during provisioning. Refer to [Transforms in Provisioning Policies](https://developer.sailpoint.com/idn/docs/transforms/guides/transforms-in-provisioning-policies) for more information. A token with API, ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		     * @summary Partial update of Provisioning Policy
		     * @param {SourcesBetaApiUpdateProvisioningPolicyRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SourcesBetaApi
		     */
		    SourcesBetaApi.prototype.updateProvisioningPolicy = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SourcesBetaApiFp)(this.configuration).updateProvisioningPolicy(requestParameters.sourceId, requestParameters.usageType, requestParameters.jsonPatchOperationBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API partially updates a source in IdentityNow, using a list of patch operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.  Some fields are immutable and cannot be changed, such as: * id * type * authoritative * created * modified * connector * connectorClass * passwordPolicies  Attempts to modify these fields will result in a 400 error.  A token with ORG_ADMIN, SOURCE_ADMIN, SOURCE_SUBADMIN, or API authority is required to call this API.
		     * @summary Update Source (Partial)
		     * @param {SourcesBetaApiUpdateSourceRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SourcesBetaApi
		     */
		    SourcesBetaApi.prototype.updateSource = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SourcesBetaApiFp)(this.configuration).updateSource(requestParameters.id, requestParameters.jsonPatchOperationBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API replaces the current entitlement request configuration for a source. This source-level configuration should apply for all the entitlements in the source.  Access request to any entitlements in the source should follow this configuration unless a separate entitlement-level configuration is defined. - During access request, this source-level entitlement request configuration overrides the global organization-level configuration. - However, the entitlement-level configuration (if defined) overrides this source-level configuration.  A token with ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		     * @summary Update Source Entitlement Request Configuration
		     * @param {SourcesBetaApiUpdateSourceEntitlementRequestConfigRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SourcesBetaApi
		     */
		    SourcesBetaApi.prototype.updateSourceEntitlementRequestConfig = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SourcesBetaApiFp)(this.configuration).updateSourceEntitlementRequestConfig(requestParameters.sourceEntitlementRequestConfigBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Use this API to selectively update an existing Schema using a JSONPatch payload.   The following schema fields are immutable and cannot be updated:  - id - name - created - modified   To switch an account attribute to a group entitlement, you need to have the following in place:  - `isEntitlement: true` - Must define a schema for the group and [add it to the source](https://developer.sailpoint.com/idn/api/beta/create-source-schema) before updating the `isGroup` flag.  For example, here is the `group` account attribute referencing a schema that defines the group: ```json {     \"name\": \"groups\",     \"type\": \"STRING\",     \"schema\": {         \"type\": \"CONNECTOR_SCHEMA\",         \"id\": \"2c9180887671ff8c01767b4671fc7d60\",         \"name\": \"group\"     },     \"description\": \"The groups, roles etc. that reference account group objects\",     \"isMulti\": true,     \"isEntitlement\": true,     \"isGroup\": true } ```
		     * @summary Update Source Schema (Partial)
		     * @param {SourcesBetaApiUpdateSourceSchemaRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SourcesBetaApi
		     */
		    SourcesBetaApi.prototype.updateSourceSchema = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SourcesBetaApiFp)(this.configuration).updateSourceSchema(requestParameters.sourceId, requestParameters.schemaId, requestParameters.jsonPatchOperationBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return SourcesBetaApi;
		}(base_1.BaseAPI));
		exports.SourcesBetaApi = SourcesBetaApi;
		/**
		 * TaggedObjectsBetaApi - axios parameter creator
		 * @export
		 */
		var TaggedObjectsBetaApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * This deletes a tagged object for the specified type.
		         * @summary Delete Tagged Object
		         * @param {'ACCESS_PROFILE' | 'APPLICATION' | 'CAMPAIGN' | 'ENTITLEMENT' | 'IDENTITY' | 'ROLE' | 'SOD_POLICY' | 'SOURCE'} type The type of tagged object to delete.
		         * @param {string} id The ID of the object reference to delete.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteTaggedObject: function (type, id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'type' is not null or undefined
		                            (0, common_1.assertParamExists)('deleteTaggedObject', 'type', type);
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('deleteTaggedObject', 'id', id);
		                            localVarPath = "/tagged-objects/{type}/{id}"
		                                .replace("{".concat("type", "}"), encodeURIComponent(String(type)))
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'DELETE' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API removes tags from multiple objects.  A token with API, CERT_ADMIN, ORG_ADMIN, REPORT_ADMIN, ROLE_ADMIN, ROLE_SUBADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		         * @summary Remove Tags from Multiple Objects
		         * @param {BulkTaggedObjectBeta} bulkTaggedObjectBeta Supported object types are ACCESS_PROFILE, APPLICATION, CAMPAIGN, ENTITLEMENT, IDENTITY, ROLE, SOD_POLICY, SOURCE.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteTagsToManyObject: function (bulkTaggedObjectBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'bulkTaggedObjectBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('deleteTagsToManyObject', 'bulkTaggedObjectBeta', bulkTaggedObjectBeta);
		                            localVarPath = "/tagged-objects/bulk-remove";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(bulkTaggedObjectBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets a tagged object for the specified type.
		         * @summary Get Tagged Object
		         * @param {'ACCESS_PROFILE' | 'APPLICATION' | 'CAMPAIGN' | 'ENTITLEMENT' | 'IDENTITY' | 'ROLE' | 'SOD_POLICY' | 'SOURCE'} type The type of tagged object to retrieve.
		         * @param {string} id The ID of the object reference to retrieve.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getTaggedObject: function (type, id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'type' is not null or undefined
		                            (0, common_1.assertParamExists)('getTaggedObject', 'type', type);
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getTaggedObject', 'id', id);
		                            localVarPath = "/tagged-objects/{type}/{id}"
		                                .replace("{".concat("type", "}"), encodeURIComponent(String(type)))
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns a list of all tagged objects.  Any authenticated token may be used to call this API.
		         * @summary List Tagged Objects
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **objectRef.id**: *eq, in*  **objectRef.type**: *eq, in*  **tagName**: *eq, in*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listTaggedObjects: function (limit, offset, count, filters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/tagged-objects";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns a list of all tagged objects by type.  Any authenticated token may be used to call this API.
		         * @summary List Tagged Objects by Type
		         * @param {'ACCESS_PROFILE' | 'APPLICATION' | 'CAMPAIGN' | 'ENTITLEMENT' | 'IDENTITY' | 'ROLE' | 'SOD_POLICY' | 'SOURCE'} type The type of tagged object to retrieve.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **objectRef.id**: *eq*  **objectRef.type**: *eq*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listTaggedObjectsByType: function (type, limit, offset, count, filters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'type' is not null or undefined
		                            (0, common_1.assertParamExists)('listTaggedObjectsByType', 'type', type);
		                            localVarPath = "/tagged-objects/{type}"
		                                .replace("{".concat("type", "}"), encodeURIComponent(String(type)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This updates a tagged object for the specified type.
		         * @summary Update Tagged Object
		         * @param {'ACCESS_PROFILE' | 'APPLICATION' | 'CAMPAIGN' | 'ENTITLEMENT' | 'IDENTITY' | 'ROLE' | 'SOD_POLICY' | 'SOURCE'} type The type of tagged object to update.
		         * @param {string} id The ID of the object reference to update.
		         * @param {TaggedObjectBeta} taggedObjectBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putTaggedObject: function (type, id, taggedObjectBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'type' is not null or undefined
		                            (0, common_1.assertParamExists)('putTaggedObject', 'type', type);
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('putTaggedObject', 'id', id);
		                            // verify required parameter 'taggedObjectBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('putTaggedObject', 'taggedObjectBeta', taggedObjectBeta);
		                            localVarPath = "/tagged-objects/{type}/{id}"
		                                .replace("{".concat("type", "}"), encodeURIComponent(String(type)))
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PUT' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(taggedObjectBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This adds a tag to an object.  Any authenticated token may be used to call this API.
		         * @summary Add Tag to Object
		         * @param {TaggedObjectBeta} taggedObjectBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        setTagToObject: function (taggedObjectBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'taggedObjectBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('setTagToObject', 'taggedObjectBeta', taggedObjectBeta);
		                            localVarPath = "/tagged-objects";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(taggedObjectBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API adds tags to multiple objects.  A token with API, CERT_ADMIN, ORG_ADMIN, REPORT_ADMIN, ROLE_ADMIN, ROLE_SUBADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		         * @summary Tag Multiple Objects
		         * @param {BulkTaggedObjectBeta} bulkTaggedObjectBeta Supported object types are ACCESS_PROFILE, APPLICATION, CAMPAIGN, ENTITLEMENT, IDENTITY, ROLE, SOD_POLICY, SOURCE.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        setTagsToManyObjects: function (bulkTaggedObjectBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'bulkTaggedObjectBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('setTagsToManyObjects', 'bulkTaggedObjectBeta', bulkTaggedObjectBeta);
		                            localVarPath = "/tagged-objects/bulk-add";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(bulkTaggedObjectBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.TaggedObjectsBetaApiAxiosParamCreator = TaggedObjectsBetaApiAxiosParamCreator;
		/**
		 * TaggedObjectsBetaApi - functional programming interface
		 * @export
		 */
		var TaggedObjectsBetaApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.TaggedObjectsBetaApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * This deletes a tagged object for the specified type.
		         * @summary Delete Tagged Object
		         * @param {'ACCESS_PROFILE' | 'APPLICATION' | 'CAMPAIGN' | 'ENTITLEMENT' | 'IDENTITY' | 'ROLE' | 'SOD_POLICY' | 'SOURCE'} type The type of tagged object to delete.
		         * @param {string} id The ID of the object reference to delete.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteTaggedObject: function (type, id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.deleteTaggedObject(type, id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API removes tags from multiple objects.  A token with API, CERT_ADMIN, ORG_ADMIN, REPORT_ADMIN, ROLE_ADMIN, ROLE_SUBADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		         * @summary Remove Tags from Multiple Objects
		         * @param {BulkTaggedObjectBeta} bulkTaggedObjectBeta Supported object types are ACCESS_PROFILE, APPLICATION, CAMPAIGN, ENTITLEMENT, IDENTITY, ROLE, SOD_POLICY, SOURCE.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteTagsToManyObject: function (bulkTaggedObjectBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.deleteTagsToManyObject(bulkTaggedObjectBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets a tagged object for the specified type.
		         * @summary Get Tagged Object
		         * @param {'ACCESS_PROFILE' | 'APPLICATION' | 'CAMPAIGN' | 'ENTITLEMENT' | 'IDENTITY' | 'ROLE' | 'SOD_POLICY' | 'SOURCE'} type The type of tagged object to retrieve.
		         * @param {string} id The ID of the object reference to retrieve.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getTaggedObject: function (type, id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getTaggedObject(type, id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns a list of all tagged objects.  Any authenticated token may be used to call this API.
		         * @summary List Tagged Objects
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **objectRef.id**: *eq, in*  **objectRef.type**: *eq, in*  **tagName**: *eq, in*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listTaggedObjects: function (limit, offset, count, filters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listTaggedObjects(limit, offset, count, filters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns a list of all tagged objects by type.  Any authenticated token may be used to call this API.
		         * @summary List Tagged Objects by Type
		         * @param {'ACCESS_PROFILE' | 'APPLICATION' | 'CAMPAIGN' | 'ENTITLEMENT' | 'IDENTITY' | 'ROLE' | 'SOD_POLICY' | 'SOURCE'} type The type of tagged object to retrieve.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **objectRef.id**: *eq*  **objectRef.type**: *eq*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listTaggedObjectsByType: function (type, limit, offset, count, filters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listTaggedObjectsByType(type, limit, offset, count, filters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This updates a tagged object for the specified type.
		         * @summary Update Tagged Object
		         * @param {'ACCESS_PROFILE' | 'APPLICATION' | 'CAMPAIGN' | 'ENTITLEMENT' | 'IDENTITY' | 'ROLE' | 'SOD_POLICY' | 'SOURCE'} type The type of tagged object to update.
		         * @param {string} id The ID of the object reference to update.
		         * @param {TaggedObjectBeta} taggedObjectBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putTaggedObject: function (type, id, taggedObjectBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.putTaggedObject(type, id, taggedObjectBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This adds a tag to an object.  Any authenticated token may be used to call this API.
		         * @summary Add Tag to Object
		         * @param {TaggedObjectBeta} taggedObjectBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        setTagToObject: function (taggedObjectBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.setTagToObject(taggedObjectBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API adds tags to multiple objects.  A token with API, CERT_ADMIN, ORG_ADMIN, REPORT_ADMIN, ROLE_ADMIN, ROLE_SUBADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		         * @summary Tag Multiple Objects
		         * @param {BulkTaggedObjectBeta} bulkTaggedObjectBeta Supported object types are ACCESS_PROFILE, APPLICATION, CAMPAIGN, ENTITLEMENT, IDENTITY, ROLE, SOD_POLICY, SOURCE.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        setTagsToManyObjects: function (bulkTaggedObjectBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.setTagsToManyObjects(bulkTaggedObjectBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.TaggedObjectsBetaApiFp = TaggedObjectsBetaApiFp;
		/**
		 * TaggedObjectsBetaApi - factory interface
		 * @export
		 */
		var TaggedObjectsBetaApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.TaggedObjectsBetaApiFp)(configuration);
		    return {
		        /**
		         * This deletes a tagged object for the specified type.
		         * @summary Delete Tagged Object
		         * @param {'ACCESS_PROFILE' | 'APPLICATION' | 'CAMPAIGN' | 'ENTITLEMENT' | 'IDENTITY' | 'ROLE' | 'SOD_POLICY' | 'SOURCE'} type The type of tagged object to delete.
		         * @param {string} id The ID of the object reference to delete.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteTaggedObject: function (type, id, axiosOptions) {
		            return localVarFp.deleteTaggedObject(type, id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API removes tags from multiple objects.  A token with API, CERT_ADMIN, ORG_ADMIN, REPORT_ADMIN, ROLE_ADMIN, ROLE_SUBADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		         * @summary Remove Tags from Multiple Objects
		         * @param {BulkTaggedObjectBeta} bulkTaggedObjectBeta Supported object types are ACCESS_PROFILE, APPLICATION, CAMPAIGN, ENTITLEMENT, IDENTITY, ROLE, SOD_POLICY, SOURCE.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteTagsToManyObject: function (bulkTaggedObjectBeta, axiosOptions) {
		            return localVarFp.deleteTagsToManyObject(bulkTaggedObjectBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This gets a tagged object for the specified type.
		         * @summary Get Tagged Object
		         * @param {'ACCESS_PROFILE' | 'APPLICATION' | 'CAMPAIGN' | 'ENTITLEMENT' | 'IDENTITY' | 'ROLE' | 'SOD_POLICY' | 'SOURCE'} type The type of tagged object to retrieve.
		         * @param {string} id The ID of the object reference to retrieve.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getTaggedObject: function (type, id, axiosOptions) {
		            return localVarFp.getTaggedObject(type, id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API returns a list of all tagged objects.  Any authenticated token may be used to call this API.
		         * @summary List Tagged Objects
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **objectRef.id**: *eq, in*  **objectRef.type**: *eq, in*  **tagName**: *eq, in*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listTaggedObjects: function (limit, offset, count, filters, axiosOptions) {
		            return localVarFp.listTaggedObjects(limit, offset, count, filters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API returns a list of all tagged objects by type.  Any authenticated token may be used to call this API.
		         * @summary List Tagged Objects by Type
		         * @param {'ACCESS_PROFILE' | 'APPLICATION' | 'CAMPAIGN' | 'ENTITLEMENT' | 'IDENTITY' | 'ROLE' | 'SOD_POLICY' | 'SOURCE'} type The type of tagged object to retrieve.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **objectRef.id**: *eq*  **objectRef.type**: *eq*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listTaggedObjectsByType: function (type, limit, offset, count, filters, axiosOptions) {
		            return localVarFp.listTaggedObjectsByType(type, limit, offset, count, filters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This updates a tagged object for the specified type.
		         * @summary Update Tagged Object
		         * @param {'ACCESS_PROFILE' | 'APPLICATION' | 'CAMPAIGN' | 'ENTITLEMENT' | 'IDENTITY' | 'ROLE' | 'SOD_POLICY' | 'SOURCE'} type The type of tagged object to update.
		         * @param {string} id The ID of the object reference to update.
		         * @param {TaggedObjectBeta} taggedObjectBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putTaggedObject: function (type, id, taggedObjectBeta, axiosOptions) {
		            return localVarFp.putTaggedObject(type, id, taggedObjectBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This adds a tag to an object.  Any authenticated token may be used to call this API.
		         * @summary Add Tag to Object
		         * @param {TaggedObjectBeta} taggedObjectBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        setTagToObject: function (taggedObjectBeta, axiosOptions) {
		            return localVarFp.setTagToObject(taggedObjectBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API adds tags to multiple objects.  A token with API, CERT_ADMIN, ORG_ADMIN, REPORT_ADMIN, ROLE_ADMIN, ROLE_SUBADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		         * @summary Tag Multiple Objects
		         * @param {BulkTaggedObjectBeta} bulkTaggedObjectBeta Supported object types are ACCESS_PROFILE, APPLICATION, CAMPAIGN, ENTITLEMENT, IDENTITY, ROLE, SOD_POLICY, SOURCE.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        setTagsToManyObjects: function (bulkTaggedObjectBeta, axiosOptions) {
		            return localVarFp.setTagsToManyObjects(bulkTaggedObjectBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.TaggedObjectsBetaApiFactory = TaggedObjectsBetaApiFactory;
		/**
		 * TaggedObjectsBetaApi - object-oriented interface
		 * @export
		 * @class TaggedObjectsBetaApi
		 * @extends {BaseAPI}
		 */
		var TaggedObjectsBetaApi = /** @class */ (function (_super) {
		    __extends(TaggedObjectsBetaApi, _super);
		    function TaggedObjectsBetaApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * This deletes a tagged object for the specified type.
		     * @summary Delete Tagged Object
		     * @param {TaggedObjectsBetaApiDeleteTaggedObjectRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof TaggedObjectsBetaApi
		     */
		    TaggedObjectsBetaApi.prototype.deleteTaggedObject = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.TaggedObjectsBetaApiFp)(this.configuration).deleteTaggedObject(requestParameters.type, requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API removes tags from multiple objects.  A token with API, CERT_ADMIN, ORG_ADMIN, REPORT_ADMIN, ROLE_ADMIN, ROLE_SUBADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		     * @summary Remove Tags from Multiple Objects
		     * @param {TaggedObjectsBetaApiDeleteTagsToManyObjectRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof TaggedObjectsBetaApi
		     */
		    TaggedObjectsBetaApi.prototype.deleteTagsToManyObject = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.TaggedObjectsBetaApiFp)(this.configuration).deleteTagsToManyObject(requestParameters.bulkTaggedObjectBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This gets a tagged object for the specified type.
		     * @summary Get Tagged Object
		     * @param {TaggedObjectsBetaApiGetTaggedObjectRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof TaggedObjectsBetaApi
		     */
		    TaggedObjectsBetaApi.prototype.getTaggedObject = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.TaggedObjectsBetaApiFp)(this.configuration).getTaggedObject(requestParameters.type, requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API returns a list of all tagged objects.  Any authenticated token may be used to call this API.
		     * @summary List Tagged Objects
		     * @param {TaggedObjectsBetaApiListTaggedObjectsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof TaggedObjectsBetaApi
		     */
		    TaggedObjectsBetaApi.prototype.listTaggedObjects = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.TaggedObjectsBetaApiFp)(this.configuration).listTaggedObjects(requestParameters.limit, requestParameters.offset, requestParameters.count, requestParameters.filters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API returns a list of all tagged objects by type.  Any authenticated token may be used to call this API.
		     * @summary List Tagged Objects by Type
		     * @param {TaggedObjectsBetaApiListTaggedObjectsByTypeRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof TaggedObjectsBetaApi
		     */
		    TaggedObjectsBetaApi.prototype.listTaggedObjectsByType = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.TaggedObjectsBetaApiFp)(this.configuration).listTaggedObjectsByType(requestParameters.type, requestParameters.limit, requestParameters.offset, requestParameters.count, requestParameters.filters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This updates a tagged object for the specified type.
		     * @summary Update Tagged Object
		     * @param {TaggedObjectsBetaApiPutTaggedObjectRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof TaggedObjectsBetaApi
		     */
		    TaggedObjectsBetaApi.prototype.putTaggedObject = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.TaggedObjectsBetaApiFp)(this.configuration).putTaggedObject(requestParameters.type, requestParameters.id, requestParameters.taggedObjectBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This adds a tag to an object.  Any authenticated token may be used to call this API.
		     * @summary Add Tag to Object
		     * @param {TaggedObjectsBetaApiSetTagToObjectRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof TaggedObjectsBetaApi
		     */
		    TaggedObjectsBetaApi.prototype.setTagToObject = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.TaggedObjectsBetaApiFp)(this.configuration).setTagToObject(requestParameters.taggedObjectBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API adds tags to multiple objects.  A token with API, CERT_ADMIN, ORG_ADMIN, REPORT_ADMIN, ROLE_ADMIN, ROLE_SUBADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		     * @summary Tag Multiple Objects
		     * @param {TaggedObjectsBetaApiSetTagsToManyObjectsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof TaggedObjectsBetaApi
		     */
		    TaggedObjectsBetaApi.prototype.setTagsToManyObjects = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.TaggedObjectsBetaApiFp)(this.configuration).setTagsToManyObjects(requestParameters.bulkTaggedObjectBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return TaggedObjectsBetaApi;
		}(base_1.BaseAPI));
		exports.TaggedObjectsBetaApi = TaggedObjectsBetaApi;
		/**
		 * TaskManagementBetaApi - axios parameter creator
		 * @export
		 */
		var TaskManagementBetaApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * Retrieve headers for a list of TaskStatus for pending tasks.
		         * @summary Retrieve headers only for pending task list.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getPendingTaskHeaders: function (offset, limit, count, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/task-status/pending-tasks";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'HEAD' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Retrieve a list of TaskStatus for pending tasks.
		         * @summary Retrieve a pending task list.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getPendingTasks: function (offset, limit, count, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/task-status/pending-tasks";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Get a TaskStatus for a task by task ID.
		         * @summary Get task status by ID.
		         * @param {string} id Task ID of the TaskStatus to get
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getTaskStatus: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getTaskStatus', 'id', id);
		                            localVarPath = "/task-status/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Get a TaskStatus list.
		         * @summary Retrieve a task status list.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **sourceId**: *eq, in*  **completionStatus**: *eq, in*  **type**: *eq, in*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **created**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getTaskStatusList: function (limit, offset, count, filters, sorters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/task-status";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Update a current TaskStatus for a task by task ID.
		         * @summary Update task status by ID
		         * @param {string} id Task ID of the task whose TaskStatus to update
		         * @param {JsonPatchBeta} jsonPatchBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateTaskStatus: function (id, jsonPatchBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('updateTaskStatus', 'id', id);
		                            // verify required parameter 'jsonPatchBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('updateTaskStatus', 'jsonPatchBeta', jsonPatchBeta);
		                            localVarPath = "/task-status/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PATCH' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json-patch+json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(jsonPatchBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.TaskManagementBetaApiAxiosParamCreator = TaskManagementBetaApiAxiosParamCreator;
		/**
		 * TaskManagementBetaApi - functional programming interface
		 * @export
		 */
		var TaskManagementBetaApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.TaskManagementBetaApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * Retrieve headers for a list of TaskStatus for pending tasks.
		         * @summary Retrieve headers only for pending task list.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getPendingTaskHeaders: function (offset, limit, count, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getPendingTaskHeaders(offset, limit, count, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Retrieve a list of TaskStatus for pending tasks.
		         * @summary Retrieve a pending task list.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getPendingTasks: function (offset, limit, count, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getPendingTasks(offset, limit, count, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Get a TaskStatus for a task by task ID.
		         * @summary Get task status by ID.
		         * @param {string} id Task ID of the TaskStatus to get
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getTaskStatus: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getTaskStatus(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Get a TaskStatus list.
		         * @summary Retrieve a task status list.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **sourceId**: *eq, in*  **completionStatus**: *eq, in*  **type**: *eq, in*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **created**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getTaskStatusList: function (limit, offset, count, filters, sorters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getTaskStatusList(limit, offset, count, filters, sorters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Update a current TaskStatus for a task by task ID.
		         * @summary Update task status by ID
		         * @param {string} id Task ID of the task whose TaskStatus to update
		         * @param {JsonPatchBeta} jsonPatchBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateTaskStatus: function (id, jsonPatchBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.updateTaskStatus(id, jsonPatchBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.TaskManagementBetaApiFp = TaskManagementBetaApiFp;
		/**
		 * TaskManagementBetaApi - factory interface
		 * @export
		 */
		var TaskManagementBetaApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.TaskManagementBetaApiFp)(configuration);
		    return {
		        /**
		         * Retrieve headers for a list of TaskStatus for pending tasks.
		         * @summary Retrieve headers only for pending task list.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getPendingTaskHeaders: function (offset, limit, count, axiosOptions) {
		            return localVarFp.getPendingTaskHeaders(offset, limit, count, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Retrieve a list of TaskStatus for pending tasks.
		         * @summary Retrieve a pending task list.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getPendingTasks: function (offset, limit, count, axiosOptions) {
		            return localVarFp.getPendingTasks(offset, limit, count, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Get a TaskStatus for a task by task ID.
		         * @summary Get task status by ID.
		         * @param {string} id Task ID of the TaskStatus to get
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getTaskStatus: function (id, axiosOptions) {
		            return localVarFp.getTaskStatus(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Get a TaskStatus list.
		         * @summary Retrieve a task status list.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **sourceId**: *eq, in*  **completionStatus**: *eq, in*  **type**: *eq, in*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **created**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getTaskStatusList: function (limit, offset, count, filters, sorters, axiosOptions) {
		            return localVarFp.getTaskStatusList(limit, offset, count, filters, sorters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Update a current TaskStatus for a task by task ID.
		         * @summary Update task status by ID
		         * @param {string} id Task ID of the task whose TaskStatus to update
		         * @param {JsonPatchBeta} jsonPatchBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateTaskStatus: function (id, jsonPatchBeta, axiosOptions) {
		            return localVarFp.updateTaskStatus(id, jsonPatchBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.TaskManagementBetaApiFactory = TaskManagementBetaApiFactory;
		/**
		 * TaskManagementBetaApi - object-oriented interface
		 * @export
		 * @class TaskManagementBetaApi
		 * @extends {BaseAPI}
		 */
		var TaskManagementBetaApi = /** @class */ (function (_super) {
		    __extends(TaskManagementBetaApi, _super);
		    function TaskManagementBetaApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * Retrieve headers for a list of TaskStatus for pending tasks.
		     * @summary Retrieve headers only for pending task list.
		     * @param {TaskManagementBetaApiGetPendingTaskHeadersRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof TaskManagementBetaApi
		     */
		    TaskManagementBetaApi.prototype.getPendingTaskHeaders = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.TaskManagementBetaApiFp)(this.configuration).getPendingTaskHeaders(requestParameters.offset, requestParameters.limit, requestParameters.count, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Retrieve a list of TaskStatus for pending tasks.
		     * @summary Retrieve a pending task list.
		     * @param {TaskManagementBetaApiGetPendingTasksRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof TaskManagementBetaApi
		     */
		    TaskManagementBetaApi.prototype.getPendingTasks = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.TaskManagementBetaApiFp)(this.configuration).getPendingTasks(requestParameters.offset, requestParameters.limit, requestParameters.count, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Get a TaskStatus for a task by task ID.
		     * @summary Get task status by ID.
		     * @param {TaskManagementBetaApiGetTaskStatusRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof TaskManagementBetaApi
		     */
		    TaskManagementBetaApi.prototype.getTaskStatus = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.TaskManagementBetaApiFp)(this.configuration).getTaskStatus(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Get a TaskStatus list.
		     * @summary Retrieve a task status list.
		     * @param {TaskManagementBetaApiGetTaskStatusListRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof TaskManagementBetaApi
		     */
		    TaskManagementBetaApi.prototype.getTaskStatusList = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.TaskManagementBetaApiFp)(this.configuration).getTaskStatusList(requestParameters.limit, requestParameters.offset, requestParameters.count, requestParameters.filters, requestParameters.sorters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Update a current TaskStatus for a task by task ID.
		     * @summary Update task status by ID
		     * @param {TaskManagementBetaApiUpdateTaskStatusRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof TaskManagementBetaApi
		     */
		    TaskManagementBetaApi.prototype.updateTaskStatus = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.TaskManagementBetaApiFp)(this.configuration).updateTaskStatus(requestParameters.id, requestParameters.jsonPatchBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return TaskManagementBetaApi;
		}(base_1.BaseAPI));
		exports.TaskManagementBetaApi = TaskManagementBetaApi;
		/**
		 * TransformsBetaApi - axios parameter creator
		 * @export
		 */
		var TransformsBetaApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * Creates a new transform object immediately. By default, the internal flag is set to false to indicate that this is a custom transform. Only SailPoint employees have the ability to create a transform with internal set to true. Newly created Transforms can be used in the Identity Profile mappings within the UI. A token with transform write authority is required to call this API.
		         * @summary Create transform
		         * @param {TransformBeta} transformBeta The transform to be created.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createTransform: function (transformBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'transformBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('createTransform', 'transformBeta', transformBeta);
		                            localVarPath = "/transforms";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(transformBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Deletes the transform specified by the given ID. Attempting to delete a transform that is used in one or more Identity Profile mappings will result in an error. If this occurs, you must first remove the transform from all mappings before deleting the transform. A token with transform delete authority is required to call this API.
		         * @summary Delete a transform
		         * @param {string} id ID of the transform to delete
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteTransform: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('deleteTransform', 'id', id);
		                            localVarPath = "/transforms/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'DELETE' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns the transform specified by the given ID. A token with transform read authority is required to call this API.
		         * @summary Transform by ID
		         * @param {string} id ID of the transform to retrieve
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getTransform: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getTransform', 'id', id);
		                            localVarPath = "/transforms/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Gets a list of all saved transform objects. A token with transforms-list read authority is required to call this API.
		         * @summary List transforms
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [name] Name of the transform to retrieve from the list.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **internal**: *eq*  **name**: *eq, sw*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listTransforms: function (offset, limit, count, name, filters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/transforms";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (name !== undefined) {
		                                localVarQueryParameter['name'] = name;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Replaces the transform specified by the given ID with the transform provided in the request body. Only the \"attributes\" field is mutable. Attempting to change other properties (ex. \"name\" and \"type\") will result in an error. A token with transform write authority is required to call this API.
		         * @summary Update a transform
		         * @param {string} id ID of the transform to update
		         * @param {TransformBeta} [transformBeta] The updated transform object. Must include \&quot;name\&quot;, \&quot;type\&quot;, and \&quot;attributes\&quot; fields, but \&quot;name\&quot; and \&quot;type\&quot; must not be modified.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateTransform: function (id, transformBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('updateTransform', 'id', id);
		                            localVarPath = "/transforms/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PUT' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(transformBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.TransformsBetaApiAxiosParamCreator = TransformsBetaApiAxiosParamCreator;
		/**
		 * TransformsBetaApi - functional programming interface
		 * @export
		 */
		var TransformsBetaApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.TransformsBetaApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * Creates a new transform object immediately. By default, the internal flag is set to false to indicate that this is a custom transform. Only SailPoint employees have the ability to create a transform with internal set to true. Newly created Transforms can be used in the Identity Profile mappings within the UI. A token with transform write authority is required to call this API.
		         * @summary Create transform
		         * @param {TransformBeta} transformBeta The transform to be created.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createTransform: function (transformBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.createTransform(transformBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Deletes the transform specified by the given ID. Attempting to delete a transform that is used in one or more Identity Profile mappings will result in an error. If this occurs, you must first remove the transform from all mappings before deleting the transform. A token with transform delete authority is required to call this API.
		         * @summary Delete a transform
		         * @param {string} id ID of the transform to delete
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteTransform: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.deleteTransform(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns the transform specified by the given ID. A token with transform read authority is required to call this API.
		         * @summary Transform by ID
		         * @param {string} id ID of the transform to retrieve
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getTransform: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getTransform(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Gets a list of all saved transform objects. A token with transforms-list read authority is required to call this API.
		         * @summary List transforms
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [name] Name of the transform to retrieve from the list.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **internal**: *eq*  **name**: *eq, sw*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listTransforms: function (offset, limit, count, name, filters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listTransforms(offset, limit, count, name, filters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Replaces the transform specified by the given ID with the transform provided in the request body. Only the \"attributes\" field is mutable. Attempting to change other properties (ex. \"name\" and \"type\") will result in an error. A token with transform write authority is required to call this API.
		         * @summary Update a transform
		         * @param {string} id ID of the transform to update
		         * @param {TransformBeta} [transformBeta] The updated transform object. Must include \&quot;name\&quot;, \&quot;type\&quot;, and \&quot;attributes\&quot; fields, but \&quot;name\&quot; and \&quot;type\&quot; must not be modified.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateTransform: function (id, transformBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.updateTransform(id, transformBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.TransformsBetaApiFp = TransformsBetaApiFp;
		/**
		 * TransformsBetaApi - factory interface
		 * @export
		 */
		var TransformsBetaApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.TransformsBetaApiFp)(configuration);
		    return {
		        /**
		         * Creates a new transform object immediately. By default, the internal flag is set to false to indicate that this is a custom transform. Only SailPoint employees have the ability to create a transform with internal set to true. Newly created Transforms can be used in the Identity Profile mappings within the UI. A token with transform write authority is required to call this API.
		         * @summary Create transform
		         * @param {TransformBeta} transformBeta The transform to be created.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createTransform: function (transformBeta, axiosOptions) {
		            return localVarFp.createTransform(transformBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Deletes the transform specified by the given ID. Attempting to delete a transform that is used in one or more Identity Profile mappings will result in an error. If this occurs, you must first remove the transform from all mappings before deleting the transform. A token with transform delete authority is required to call this API.
		         * @summary Delete a transform
		         * @param {string} id ID of the transform to delete
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteTransform: function (id, axiosOptions) {
		            return localVarFp.deleteTransform(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API returns the transform specified by the given ID. A token with transform read authority is required to call this API.
		         * @summary Transform by ID
		         * @param {string} id ID of the transform to retrieve
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getTransform: function (id, axiosOptions) {
		            return localVarFp.getTransform(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Gets a list of all saved transform objects. A token with transforms-list read authority is required to call this API.
		         * @summary List transforms
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [name] Name of the transform to retrieve from the list.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **internal**: *eq*  **name**: *eq, sw*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listTransforms: function (offset, limit, count, name, filters, axiosOptions) {
		            return localVarFp.listTransforms(offset, limit, count, name, filters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Replaces the transform specified by the given ID with the transform provided in the request body. Only the \"attributes\" field is mutable. Attempting to change other properties (ex. \"name\" and \"type\") will result in an error. A token with transform write authority is required to call this API.
		         * @summary Update a transform
		         * @param {string} id ID of the transform to update
		         * @param {TransformBeta} [transformBeta] The updated transform object. Must include \&quot;name\&quot;, \&quot;type\&quot;, and \&quot;attributes\&quot; fields, but \&quot;name\&quot; and \&quot;type\&quot; must not be modified.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateTransform: function (id, transformBeta, axiosOptions) {
		            return localVarFp.updateTransform(id, transformBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.TransformsBetaApiFactory = TransformsBetaApiFactory;
		/**
		 * TransformsBetaApi - object-oriented interface
		 * @export
		 * @class TransformsBetaApi
		 * @extends {BaseAPI}
		 */
		var TransformsBetaApi = /** @class */ (function (_super) {
		    __extends(TransformsBetaApi, _super);
		    function TransformsBetaApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * Creates a new transform object immediately. By default, the internal flag is set to false to indicate that this is a custom transform. Only SailPoint employees have the ability to create a transform with internal set to true. Newly created Transforms can be used in the Identity Profile mappings within the UI. A token with transform write authority is required to call this API.
		     * @summary Create transform
		     * @param {TransformsBetaApiCreateTransformRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof TransformsBetaApi
		     */
		    TransformsBetaApi.prototype.createTransform = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.TransformsBetaApiFp)(this.configuration).createTransform(requestParameters.transformBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Deletes the transform specified by the given ID. Attempting to delete a transform that is used in one or more Identity Profile mappings will result in an error. If this occurs, you must first remove the transform from all mappings before deleting the transform. A token with transform delete authority is required to call this API.
		     * @summary Delete a transform
		     * @param {TransformsBetaApiDeleteTransformRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof TransformsBetaApi
		     */
		    TransformsBetaApi.prototype.deleteTransform = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.TransformsBetaApiFp)(this.configuration).deleteTransform(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API returns the transform specified by the given ID. A token with transform read authority is required to call this API.
		     * @summary Transform by ID
		     * @param {TransformsBetaApiGetTransformRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof TransformsBetaApi
		     */
		    TransformsBetaApi.prototype.getTransform = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.TransformsBetaApiFp)(this.configuration).getTransform(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Gets a list of all saved transform objects. A token with transforms-list read authority is required to call this API.
		     * @summary List transforms
		     * @param {TransformsBetaApiListTransformsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof TransformsBetaApi
		     */
		    TransformsBetaApi.prototype.listTransforms = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.TransformsBetaApiFp)(this.configuration).listTransforms(requestParameters.offset, requestParameters.limit, requestParameters.count, requestParameters.name, requestParameters.filters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Replaces the transform specified by the given ID with the transform provided in the request body. Only the \"attributes\" field is mutable. Attempting to change other properties (ex. \"name\" and \"type\") will result in an error. A token with transform write authority is required to call this API.
		     * @summary Update a transform
		     * @param {TransformsBetaApiUpdateTransformRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof TransformsBetaApi
		     */
		    TransformsBetaApi.prototype.updateTransform = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.TransformsBetaApiFp)(this.configuration).updateTransform(requestParameters.id, requestParameters.transformBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return TransformsBetaApi;
		}(base_1.BaseAPI));
		exports.TransformsBetaApi = TransformsBetaApi;
		/**
		 * TriggersBetaApi - axios parameter creator
		 * @export
		 */
		var TriggersBetaApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * Completes an invocation to a REQUEST_RESPONSE type trigger.
		         * @summary Complete Trigger Invocation
		         * @param {string} id The ID of the invocation to complete.
		         * @param {CompleteInvocationBeta} completeInvocationBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        completeTriggerInvocation: function (id, completeInvocationBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('completeTriggerInvocation', 'id', id);
		                            // verify required parameter 'completeInvocationBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('completeTriggerInvocation', 'completeInvocationBeta', completeInvocationBeta);
		                            localVarPath = "/trigger-invocations/{id}/complete"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(completeInvocationBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API creates a new subscription to a trigger and defines trigger invocation details. The type of subscription determines which config object is required: * HTTP subscriptions require httpConfig * EventBridge subscriptions require eventBridgeConfig
		         * @summary Create a Subscription
		         * @param {SubscriptionPostRequestBeta} subscriptionPostRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createSubscription: function (subscriptionPostRequestBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'subscriptionPostRequestBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('createSubscription', 'subscriptionPostRequestBeta', subscriptionPostRequestBeta);
		                            localVarPath = "/trigger-subscriptions";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(subscriptionPostRequestBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Deletes an existing subscription to a trigger.
		         * @summary Delete a Subscription
		         * @param {string} id Subscription ID
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteSubscription: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('deleteSubscription', 'id', id);
		                            localVarPath = "/trigger-subscriptions/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'DELETE' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Gets a list of all trigger subscriptions.
		         * @summary List Subscriptions
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq*  **triggerId**: *eq*  **type**: *eq, le*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **triggerId, triggerName**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listSubscriptions: function (limit, offset, count, filters, sorters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/trigger-subscriptions";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Gets a list of latest invocation statuses. Statuses of successful invocations are available for up to 24 hours. Statuses of failed invocations are available for up to 48 hours. This endpoint may only fetch up to 2000 invocations, and should not be treated as a representation of the full history of invocations.
		         * @summary List Latest Invocation Statuses
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **triggerId**: *eq*  **subscriptionId**: *eq*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **triggerId, subscriptionName, created, completed**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listTriggerInvocationStatus: function (limit, offset, count, filters, sorters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/trigger-invocations/status";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Gets a list of triggers that are available in the tenant.
		         * @summary List Triggers
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, ge, le*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **id, name**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listTriggers: function (limit, offset, count, filters, sorters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/triggers";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API updates a trigger subscription in IdentityNow, using a set of instructions to modify a subscription partially. The following fields are patchable:  **name**, **description**, **enabled**, **type**, **filter**, **responseDeadline**, **httpConfig**, **eventBridgeConfig**, **workflowConfig**
		         * @summary Patch a Subscription
		         * @param {string} id ID of the Subscription to patch
		         * @param {Array<SubscriptionPatchRequestInnerBeta>} subscriptionPatchRequestInnerBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchSubscription: function (id, subscriptionPatchRequestInnerBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('patchSubscription', 'id', id);
		                            // verify required parameter 'subscriptionPatchRequestInnerBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('patchSubscription', 'subscriptionPatchRequestInnerBeta', subscriptionPatchRequestInnerBeta);
		                            localVarPath = "/trigger-subscriptions/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PATCH' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json-patch+json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(subscriptionPatchRequestInnerBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Initiate a test event for all subscribers of the specified event trigger.  If there are no subscribers to the specified trigger in the tenant, then no test event will be sent.
		         * @summary Start a Test Invocation
		         * @param {TestInvocationBeta} testInvocationBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        startTestTriggerInvocation: function (testInvocationBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'testInvocationBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('startTestTriggerInvocation', 'testInvocationBeta', testInvocationBeta);
		                            localVarPath = "/trigger-invocations/test";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(testInvocationBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Validates a JSONPath filter expression against a provided mock input. Request requires a security scope of:
		         * @summary Validate a Subscription Filter
		         * @param {ValidateFilterInputDtoBeta} validateFilterInputDtoBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        testSubscriptionFilter: function (validateFilterInputDtoBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'validateFilterInputDtoBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('testSubscriptionFilter', 'validateFilterInputDtoBeta', validateFilterInputDtoBeta);
		                            localVarPath = "/trigger-subscriptions/validate-filter";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(validateFilterInputDtoBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API updates a trigger subscription in IdentityNow, using a full object representation. In other words, the existing   Subscription is completely replaced. The following fields are immutable:     * id    * triggerId     Attempts to modify these fields result in 400.
		         * @summary Update a Subscription
		         * @param {string} id Subscription ID
		         * @param {SubscriptionPutRequestBeta} subscriptionPutRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateSubscription: function (id, subscriptionPutRequestBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('updateSubscription', 'id', id);
		                            // verify required parameter 'subscriptionPutRequestBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('updateSubscription', 'subscriptionPutRequestBeta', subscriptionPutRequestBeta);
		                            localVarPath = "/trigger-subscriptions/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PUT' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(subscriptionPutRequestBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.TriggersBetaApiAxiosParamCreator = TriggersBetaApiAxiosParamCreator;
		/**
		 * TriggersBetaApi - functional programming interface
		 * @export
		 */
		var TriggersBetaApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.TriggersBetaApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * Completes an invocation to a REQUEST_RESPONSE type trigger.
		         * @summary Complete Trigger Invocation
		         * @param {string} id The ID of the invocation to complete.
		         * @param {CompleteInvocationBeta} completeInvocationBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        completeTriggerInvocation: function (id, completeInvocationBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.completeTriggerInvocation(id, completeInvocationBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API creates a new subscription to a trigger and defines trigger invocation details. The type of subscription determines which config object is required: * HTTP subscriptions require httpConfig * EventBridge subscriptions require eventBridgeConfig
		         * @summary Create a Subscription
		         * @param {SubscriptionPostRequestBeta} subscriptionPostRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createSubscription: function (subscriptionPostRequestBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.createSubscription(subscriptionPostRequestBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Deletes an existing subscription to a trigger.
		         * @summary Delete a Subscription
		         * @param {string} id Subscription ID
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteSubscription: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.deleteSubscription(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Gets a list of all trigger subscriptions.
		         * @summary List Subscriptions
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq*  **triggerId**: *eq*  **type**: *eq, le*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **triggerId, triggerName**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listSubscriptions: function (limit, offset, count, filters, sorters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listSubscriptions(limit, offset, count, filters, sorters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Gets a list of latest invocation statuses. Statuses of successful invocations are available for up to 24 hours. Statuses of failed invocations are available for up to 48 hours. This endpoint may only fetch up to 2000 invocations, and should not be treated as a representation of the full history of invocations.
		         * @summary List Latest Invocation Statuses
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **triggerId**: *eq*  **subscriptionId**: *eq*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **triggerId, subscriptionName, created, completed**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listTriggerInvocationStatus: function (limit, offset, count, filters, sorters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listTriggerInvocationStatus(limit, offset, count, filters, sorters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Gets a list of triggers that are available in the tenant.
		         * @summary List Triggers
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, ge, le*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **id, name**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listTriggers: function (limit, offset, count, filters, sorters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listTriggers(limit, offset, count, filters, sorters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API updates a trigger subscription in IdentityNow, using a set of instructions to modify a subscription partially. The following fields are patchable:  **name**, **description**, **enabled**, **type**, **filter**, **responseDeadline**, **httpConfig**, **eventBridgeConfig**, **workflowConfig**
		         * @summary Patch a Subscription
		         * @param {string} id ID of the Subscription to patch
		         * @param {Array<SubscriptionPatchRequestInnerBeta>} subscriptionPatchRequestInnerBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchSubscription: function (id, subscriptionPatchRequestInnerBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.patchSubscription(id, subscriptionPatchRequestInnerBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Initiate a test event for all subscribers of the specified event trigger.  If there are no subscribers to the specified trigger in the tenant, then no test event will be sent.
		         * @summary Start a Test Invocation
		         * @param {TestInvocationBeta} testInvocationBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        startTestTriggerInvocation: function (testInvocationBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.startTestTriggerInvocation(testInvocationBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Validates a JSONPath filter expression against a provided mock input. Request requires a security scope of:
		         * @summary Validate a Subscription Filter
		         * @param {ValidateFilterInputDtoBeta} validateFilterInputDtoBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        testSubscriptionFilter: function (validateFilterInputDtoBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.testSubscriptionFilter(validateFilterInputDtoBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API updates a trigger subscription in IdentityNow, using a full object representation. In other words, the existing   Subscription is completely replaced. The following fields are immutable:     * id    * triggerId     Attempts to modify these fields result in 400.
		         * @summary Update a Subscription
		         * @param {string} id Subscription ID
		         * @param {SubscriptionPutRequestBeta} subscriptionPutRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateSubscription: function (id, subscriptionPutRequestBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.updateSubscription(id, subscriptionPutRequestBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.TriggersBetaApiFp = TriggersBetaApiFp;
		/**
		 * TriggersBetaApi - factory interface
		 * @export
		 */
		var TriggersBetaApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.TriggersBetaApiFp)(configuration);
		    return {
		        /**
		         * Completes an invocation to a REQUEST_RESPONSE type trigger.
		         * @summary Complete Trigger Invocation
		         * @param {string} id The ID of the invocation to complete.
		         * @param {CompleteInvocationBeta} completeInvocationBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        completeTriggerInvocation: function (id, completeInvocationBeta, axiosOptions) {
		            return localVarFp.completeTriggerInvocation(id, completeInvocationBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API creates a new subscription to a trigger and defines trigger invocation details. The type of subscription determines which config object is required: * HTTP subscriptions require httpConfig * EventBridge subscriptions require eventBridgeConfig
		         * @summary Create a Subscription
		         * @param {SubscriptionPostRequestBeta} subscriptionPostRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createSubscription: function (subscriptionPostRequestBeta, axiosOptions) {
		            return localVarFp.createSubscription(subscriptionPostRequestBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Deletes an existing subscription to a trigger.
		         * @summary Delete a Subscription
		         * @param {string} id Subscription ID
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteSubscription: function (id, axiosOptions) {
		            return localVarFp.deleteSubscription(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Gets a list of all trigger subscriptions.
		         * @summary List Subscriptions
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq*  **triggerId**: *eq*  **type**: *eq, le*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **triggerId, triggerName**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listSubscriptions: function (limit, offset, count, filters, sorters, axiosOptions) {
		            return localVarFp.listSubscriptions(limit, offset, count, filters, sorters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Gets a list of latest invocation statuses. Statuses of successful invocations are available for up to 24 hours. Statuses of failed invocations are available for up to 48 hours. This endpoint may only fetch up to 2000 invocations, and should not be treated as a representation of the full history of invocations.
		         * @summary List Latest Invocation Statuses
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **triggerId**: *eq*  **subscriptionId**: *eq*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **triggerId, subscriptionName, created, completed**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listTriggerInvocationStatus: function (limit, offset, count, filters, sorters, axiosOptions) {
		            return localVarFp.listTriggerInvocationStatus(limit, offset, count, filters, sorters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Gets a list of triggers that are available in the tenant.
		         * @summary List Triggers
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, ge, le*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **id, name**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listTriggers: function (limit, offset, count, filters, sorters, axiosOptions) {
		            return localVarFp.listTriggers(limit, offset, count, filters, sorters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API updates a trigger subscription in IdentityNow, using a set of instructions to modify a subscription partially. The following fields are patchable:  **name**, **description**, **enabled**, **type**, **filter**, **responseDeadline**, **httpConfig**, **eventBridgeConfig**, **workflowConfig**
		         * @summary Patch a Subscription
		         * @param {string} id ID of the Subscription to patch
		         * @param {Array<SubscriptionPatchRequestInnerBeta>} subscriptionPatchRequestInnerBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchSubscription: function (id, subscriptionPatchRequestInnerBeta, axiosOptions) {
		            return localVarFp.patchSubscription(id, subscriptionPatchRequestInnerBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Initiate a test event for all subscribers of the specified event trigger.  If there are no subscribers to the specified trigger in the tenant, then no test event will be sent.
		         * @summary Start a Test Invocation
		         * @param {TestInvocationBeta} testInvocationBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        startTestTriggerInvocation: function (testInvocationBeta, axiosOptions) {
		            return localVarFp.startTestTriggerInvocation(testInvocationBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Validates a JSONPath filter expression against a provided mock input. Request requires a security scope of:
		         * @summary Validate a Subscription Filter
		         * @param {ValidateFilterInputDtoBeta} validateFilterInputDtoBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        testSubscriptionFilter: function (validateFilterInputDtoBeta, axiosOptions) {
		            return localVarFp.testSubscriptionFilter(validateFilterInputDtoBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API updates a trigger subscription in IdentityNow, using a full object representation. In other words, the existing   Subscription is completely replaced. The following fields are immutable:     * id    * triggerId     Attempts to modify these fields result in 400.
		         * @summary Update a Subscription
		         * @param {string} id Subscription ID
		         * @param {SubscriptionPutRequestBeta} subscriptionPutRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateSubscription: function (id, subscriptionPutRequestBeta, axiosOptions) {
		            return localVarFp.updateSubscription(id, subscriptionPutRequestBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.TriggersBetaApiFactory = TriggersBetaApiFactory;
		/**
		 * TriggersBetaApi - object-oriented interface
		 * @export
		 * @class TriggersBetaApi
		 * @extends {BaseAPI}
		 */
		var TriggersBetaApi = /** @class */ (function (_super) {
		    __extends(TriggersBetaApi, _super);
		    function TriggersBetaApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * Completes an invocation to a REQUEST_RESPONSE type trigger.
		     * @summary Complete Trigger Invocation
		     * @param {TriggersBetaApiCompleteTriggerInvocationRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof TriggersBetaApi
		     */
		    TriggersBetaApi.prototype.completeTriggerInvocation = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.TriggersBetaApiFp)(this.configuration).completeTriggerInvocation(requestParameters.id, requestParameters.completeInvocationBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API creates a new subscription to a trigger and defines trigger invocation details. The type of subscription determines which config object is required: * HTTP subscriptions require httpConfig * EventBridge subscriptions require eventBridgeConfig
		     * @summary Create a Subscription
		     * @param {TriggersBetaApiCreateSubscriptionRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof TriggersBetaApi
		     */
		    TriggersBetaApi.prototype.createSubscription = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.TriggersBetaApiFp)(this.configuration).createSubscription(requestParameters.subscriptionPostRequestBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Deletes an existing subscription to a trigger.
		     * @summary Delete a Subscription
		     * @param {TriggersBetaApiDeleteSubscriptionRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof TriggersBetaApi
		     */
		    TriggersBetaApi.prototype.deleteSubscription = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.TriggersBetaApiFp)(this.configuration).deleteSubscription(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Gets a list of all trigger subscriptions.
		     * @summary List Subscriptions
		     * @param {TriggersBetaApiListSubscriptionsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof TriggersBetaApi
		     */
		    TriggersBetaApi.prototype.listSubscriptions = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.TriggersBetaApiFp)(this.configuration).listSubscriptions(requestParameters.limit, requestParameters.offset, requestParameters.count, requestParameters.filters, requestParameters.sorters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Gets a list of latest invocation statuses. Statuses of successful invocations are available for up to 24 hours. Statuses of failed invocations are available for up to 48 hours. This endpoint may only fetch up to 2000 invocations, and should not be treated as a representation of the full history of invocations.
		     * @summary List Latest Invocation Statuses
		     * @param {TriggersBetaApiListTriggerInvocationStatusRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof TriggersBetaApi
		     */
		    TriggersBetaApi.prototype.listTriggerInvocationStatus = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.TriggersBetaApiFp)(this.configuration).listTriggerInvocationStatus(requestParameters.limit, requestParameters.offset, requestParameters.count, requestParameters.filters, requestParameters.sorters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Gets a list of triggers that are available in the tenant.
		     * @summary List Triggers
		     * @param {TriggersBetaApiListTriggersRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof TriggersBetaApi
		     */
		    TriggersBetaApi.prototype.listTriggers = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.TriggersBetaApiFp)(this.configuration).listTriggers(requestParameters.limit, requestParameters.offset, requestParameters.count, requestParameters.filters, requestParameters.sorters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API updates a trigger subscription in IdentityNow, using a set of instructions to modify a subscription partially. The following fields are patchable:  **name**, **description**, **enabled**, **type**, **filter**, **responseDeadline**, **httpConfig**, **eventBridgeConfig**, **workflowConfig**
		     * @summary Patch a Subscription
		     * @param {TriggersBetaApiPatchSubscriptionRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof TriggersBetaApi
		     */
		    TriggersBetaApi.prototype.patchSubscription = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.TriggersBetaApiFp)(this.configuration).patchSubscription(requestParameters.id, requestParameters.subscriptionPatchRequestInnerBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Initiate a test event for all subscribers of the specified event trigger.  If there are no subscribers to the specified trigger in the tenant, then no test event will be sent.
		     * @summary Start a Test Invocation
		     * @param {TriggersBetaApiStartTestTriggerInvocationRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof TriggersBetaApi
		     */
		    TriggersBetaApi.prototype.startTestTriggerInvocation = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.TriggersBetaApiFp)(this.configuration).startTestTriggerInvocation(requestParameters.testInvocationBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Validates a JSONPath filter expression against a provided mock input. Request requires a security scope of:
		     * @summary Validate a Subscription Filter
		     * @param {TriggersBetaApiTestSubscriptionFilterRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof TriggersBetaApi
		     */
		    TriggersBetaApi.prototype.testSubscriptionFilter = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.TriggersBetaApiFp)(this.configuration).testSubscriptionFilter(requestParameters.validateFilterInputDtoBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API updates a trigger subscription in IdentityNow, using a full object representation. In other words, the existing   Subscription is completely replaced. The following fields are immutable:     * id    * triggerId     Attempts to modify these fields result in 400.
		     * @summary Update a Subscription
		     * @param {TriggersBetaApiUpdateSubscriptionRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof TriggersBetaApi
		     */
		    TriggersBetaApi.prototype.updateSubscription = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.TriggersBetaApiFp)(this.configuration).updateSubscription(requestParameters.id, requestParameters.subscriptionPutRequestBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return TriggersBetaApi;
		}(base_1.BaseAPI));
		exports.TriggersBetaApi = TriggersBetaApi;
		/**
		 * WorkItemsBetaApi - axios parameter creator
		 * @export
		 */
		var WorkItemsBetaApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * This API approves an Approval Item. Either an admin, or the owning/current user must make this request.
		         * @summary Approve an Approval Item
		         * @param {string} id The ID of the work item
		         * @param {string} approvalItemId The ID of the approval item.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        approveApprovalItem: function (id, approvalItemId, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('approveApprovalItem', 'id', id);
		                            // verify required parameter 'approvalItemId' is not null or undefined
		                            (0, common_1.assertParamExists)('approveApprovalItem', 'approvalItemId', approvalItemId);
		                            localVarPath = "/work-items/{id}/approve/{approvalItemId}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)))
		                                .replace("{".concat("approvalItemId", "}"), encodeURIComponent(String(approvalItemId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API bulk approves Approval Items. Either an admin, or the owning/current user must make this request.
		         * @summary Bulk approve Approval Items
		         * @param {string} id The ID of the work item
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        approveApprovalItemsInBulk: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('approveApprovalItemsInBulk', 'id', id);
		                            localVarPath = "/work-items/bulk-approve/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API completes a work item. Either an admin, or the owning/current user must make this request.
		         * @summary Complete a Work Item
		         * @param {string} id The ID of the work item
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        completeWorkItem: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('completeWorkItem', 'id', id);
		                            localVarPath = "/work-items/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API forwards a work item to a new owner. Either an admin, or the owning/current user must make this request.
		         * @summary Forward a Work Item
		         * @param {string} id The ID of the work item
		         * @param {WorkItemForwardBeta} workItemForwardBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        forwardWorkItem: function (id, workItemForwardBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('forwardWorkItem', 'id', id);
		                            // verify required parameter 'workItemForwardBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('forwardWorkItem', 'workItemForwardBeta', workItemForwardBeta);
		                            localVarPath = "/work-items/{id}/forward"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(workItemForwardBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets a collection of completed work items belonging to either the specified user(admin required), or the current user.
		         * @summary Completed Work Items
		         * @param {string} [ownerId] The id of the owner of the work item list being requested.  Either an admin, or the owning/current user must make this request.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getCompletedWorkItems: function (ownerId, limit, offset, count, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/work-items/completed";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (ownerId !== undefined) {
		                                localVarQueryParameter['ownerId'] = ownerId;
		                            }
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets a count of completed work items belonging to either the specified user(admin required), or the current user.
		         * @summary Count Completed Work Items
		         * @param {string} [ownerId] ID of the work item owner.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getCountCompletedWorkItems: function (ownerId, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/work-items/count/completed";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (ownerId !== undefined) {
		                                localVarQueryParameter['ownerId'] = ownerId;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets a count of work items belonging to either the specified user(admin required), or the current user.
		         * @summary Count Work Items
		         * @param {string} [ownerId] ID of the work item owner.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getCountWorkItems: function (ownerId, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/work-items/count";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (ownerId !== undefined) {
		                                localVarQueryParameter['ownerId'] = ownerId;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets the details of a Work Item belonging to either the specified user(admin required), or the current user.
		         * @summary Get a Work Item
		         * @param {string} id ID of the work item.
		         * @param {string} [ownerId] ID of the work item owner.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getWorkItem: function (id, ownerId, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getWorkItem', 'id', id);
		                            localVarPath = "/work-items/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (ownerId !== undefined) {
		                                localVarQueryParameter['ownerId'] = ownerId;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets a summary of work items belonging to either the specified user(admin required), or the current user.
		         * @summary Work Items Summary
		         * @param {string} [ownerId] ID of the work item owner.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getWorkItemsSummary: function (ownerId, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/work-items/summary";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (ownerId !== undefined) {
		                                localVarQueryParameter['ownerId'] = ownerId;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets a collection of work items belonging to either the specified user(admin required), or the current user.
		         * @summary List Work Items
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [ownerId] ID of the work item owner.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listWorkItems: function (limit, offset, count, ownerId, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/work-items";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (ownerId !== undefined) {
		                                localVarQueryParameter['ownerId'] = ownerId;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API rejects an Approval Item. Either an admin, or the owning/current user must make this request.
		         * @summary Reject an Approval Item
		         * @param {string} id The ID of the work item
		         * @param {string} approvalItemId The ID of the approval item.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        rejectApprovalItem: function (id, approvalItemId, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('rejectApprovalItem', 'id', id);
		                            // verify required parameter 'approvalItemId' is not null or undefined
		                            (0, common_1.assertParamExists)('rejectApprovalItem', 'approvalItemId', approvalItemId);
		                            localVarPath = "/work-items/{id}/reject/{approvalItemId}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)))
		                                .replace("{".concat("approvalItemId", "}"), encodeURIComponent(String(approvalItemId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API bulk rejects Approval Items. Either an admin, or the owning/current user must make this request.
		         * @summary Bulk reject Approval Items
		         * @param {string} id The ID of the work item
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        rejectApprovalItemsInBulk: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('rejectApprovalItemsInBulk', 'id', id);
		                            localVarPath = "/work-items/bulk-reject/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API submits account selections. Either an admin, or the owning/current user must make this request.
		         * @summary Submit Account Selections
		         * @param {string} id The ID of the work item
		         * @param {{ [key: string]: any; }} requestBody Account Selection Data map, keyed on fieldName
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        submitAccountSelection: function (id, requestBody, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('submitAccountSelection', 'id', id);
		                            // verify required parameter 'requestBody' is not null or undefined
		                            (0, common_1.assertParamExists)('submitAccountSelection', 'requestBody', requestBody);
		                            localVarPath = "/work-items/{id}/submit-account-selection"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(requestBody, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.WorkItemsBetaApiAxiosParamCreator = WorkItemsBetaApiAxiosParamCreator;
		/**
		 * WorkItemsBetaApi - functional programming interface
		 * @export
		 */
		var WorkItemsBetaApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.WorkItemsBetaApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * This API approves an Approval Item. Either an admin, or the owning/current user must make this request.
		         * @summary Approve an Approval Item
		         * @param {string} id The ID of the work item
		         * @param {string} approvalItemId The ID of the approval item.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        approveApprovalItem: function (id, approvalItemId, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.approveApprovalItem(id, approvalItemId, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API bulk approves Approval Items. Either an admin, or the owning/current user must make this request.
		         * @summary Bulk approve Approval Items
		         * @param {string} id The ID of the work item
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        approveApprovalItemsInBulk: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.approveApprovalItemsInBulk(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API completes a work item. Either an admin, or the owning/current user must make this request.
		         * @summary Complete a Work Item
		         * @param {string} id The ID of the work item
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        completeWorkItem: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.completeWorkItem(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API forwards a work item to a new owner. Either an admin, or the owning/current user must make this request.
		         * @summary Forward a Work Item
		         * @param {string} id The ID of the work item
		         * @param {WorkItemForwardBeta} workItemForwardBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        forwardWorkItem: function (id, workItemForwardBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.forwardWorkItem(id, workItemForwardBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets a collection of completed work items belonging to either the specified user(admin required), or the current user.
		         * @summary Completed Work Items
		         * @param {string} [ownerId] The id of the owner of the work item list being requested.  Either an admin, or the owning/current user must make this request.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getCompletedWorkItems: function (ownerId, limit, offset, count, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getCompletedWorkItems(ownerId, limit, offset, count, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets a count of completed work items belonging to either the specified user(admin required), or the current user.
		         * @summary Count Completed Work Items
		         * @param {string} [ownerId] ID of the work item owner.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getCountCompletedWorkItems: function (ownerId, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getCountCompletedWorkItems(ownerId, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets a count of work items belonging to either the specified user(admin required), or the current user.
		         * @summary Count Work Items
		         * @param {string} [ownerId] ID of the work item owner.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getCountWorkItems: function (ownerId, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getCountWorkItems(ownerId, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets the details of a Work Item belonging to either the specified user(admin required), or the current user.
		         * @summary Get a Work Item
		         * @param {string} id ID of the work item.
		         * @param {string} [ownerId] ID of the work item owner.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getWorkItem: function (id, ownerId, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getWorkItem(id, ownerId, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets a summary of work items belonging to either the specified user(admin required), or the current user.
		         * @summary Work Items Summary
		         * @param {string} [ownerId] ID of the work item owner.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getWorkItemsSummary: function (ownerId, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getWorkItemsSummary(ownerId, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets a collection of work items belonging to either the specified user(admin required), or the current user.
		         * @summary List Work Items
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [ownerId] ID of the work item owner.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listWorkItems: function (limit, offset, count, ownerId, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listWorkItems(limit, offset, count, ownerId, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API rejects an Approval Item. Either an admin, or the owning/current user must make this request.
		         * @summary Reject an Approval Item
		         * @param {string} id The ID of the work item
		         * @param {string} approvalItemId The ID of the approval item.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        rejectApprovalItem: function (id, approvalItemId, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.rejectApprovalItem(id, approvalItemId, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API bulk rejects Approval Items. Either an admin, or the owning/current user must make this request.
		         * @summary Bulk reject Approval Items
		         * @param {string} id The ID of the work item
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        rejectApprovalItemsInBulk: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.rejectApprovalItemsInBulk(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API submits account selections. Either an admin, or the owning/current user must make this request.
		         * @summary Submit Account Selections
		         * @param {string} id The ID of the work item
		         * @param {{ [key: string]: any; }} requestBody Account Selection Data map, keyed on fieldName
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        submitAccountSelection: function (id, requestBody, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.submitAccountSelection(id, requestBody, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.WorkItemsBetaApiFp = WorkItemsBetaApiFp;
		/**
		 * WorkItemsBetaApi - factory interface
		 * @export
		 */
		var WorkItemsBetaApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.WorkItemsBetaApiFp)(configuration);
		    return {
		        /**
		         * This API approves an Approval Item. Either an admin, or the owning/current user must make this request.
		         * @summary Approve an Approval Item
		         * @param {string} id The ID of the work item
		         * @param {string} approvalItemId The ID of the approval item.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        approveApprovalItem: function (id, approvalItemId, axiosOptions) {
		            return localVarFp.approveApprovalItem(id, approvalItemId, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API bulk approves Approval Items. Either an admin, or the owning/current user must make this request.
		         * @summary Bulk approve Approval Items
		         * @param {string} id The ID of the work item
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        approveApprovalItemsInBulk: function (id, axiosOptions) {
		            return localVarFp.approveApprovalItemsInBulk(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API completes a work item. Either an admin, or the owning/current user must make this request.
		         * @summary Complete a Work Item
		         * @param {string} id The ID of the work item
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        completeWorkItem: function (id, axiosOptions) {
		            return localVarFp.completeWorkItem(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API forwards a work item to a new owner. Either an admin, or the owning/current user must make this request.
		         * @summary Forward a Work Item
		         * @param {string} id The ID of the work item
		         * @param {WorkItemForwardBeta} workItemForwardBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        forwardWorkItem: function (id, workItemForwardBeta, axiosOptions) {
		            return localVarFp.forwardWorkItem(id, workItemForwardBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This gets a collection of completed work items belonging to either the specified user(admin required), or the current user.
		         * @summary Completed Work Items
		         * @param {string} [ownerId] The id of the owner of the work item list being requested.  Either an admin, or the owning/current user must make this request.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getCompletedWorkItems: function (ownerId, limit, offset, count, axiosOptions) {
		            return localVarFp.getCompletedWorkItems(ownerId, limit, offset, count, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This gets a count of completed work items belonging to either the specified user(admin required), or the current user.
		         * @summary Count Completed Work Items
		         * @param {string} [ownerId] ID of the work item owner.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getCountCompletedWorkItems: function (ownerId, axiosOptions) {
		            return localVarFp.getCountCompletedWorkItems(ownerId, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This gets a count of work items belonging to either the specified user(admin required), or the current user.
		         * @summary Count Work Items
		         * @param {string} [ownerId] ID of the work item owner.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getCountWorkItems: function (ownerId, axiosOptions) {
		            return localVarFp.getCountWorkItems(ownerId, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This gets the details of a Work Item belonging to either the specified user(admin required), or the current user.
		         * @summary Get a Work Item
		         * @param {string} id ID of the work item.
		         * @param {string} [ownerId] ID of the work item owner.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getWorkItem: function (id, ownerId, axiosOptions) {
		            return localVarFp.getWorkItem(id, ownerId, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This gets a summary of work items belonging to either the specified user(admin required), or the current user.
		         * @summary Work Items Summary
		         * @param {string} [ownerId] ID of the work item owner.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getWorkItemsSummary: function (ownerId, axiosOptions) {
		            return localVarFp.getWorkItemsSummary(ownerId, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This gets a collection of work items belonging to either the specified user(admin required), or the current user.
		         * @summary List Work Items
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [ownerId] ID of the work item owner.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listWorkItems: function (limit, offset, count, ownerId, axiosOptions) {
		            return localVarFp.listWorkItems(limit, offset, count, ownerId, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API rejects an Approval Item. Either an admin, or the owning/current user must make this request.
		         * @summary Reject an Approval Item
		         * @param {string} id The ID of the work item
		         * @param {string} approvalItemId The ID of the approval item.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        rejectApprovalItem: function (id, approvalItemId, axiosOptions) {
		            return localVarFp.rejectApprovalItem(id, approvalItemId, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API bulk rejects Approval Items. Either an admin, or the owning/current user must make this request.
		         * @summary Bulk reject Approval Items
		         * @param {string} id The ID of the work item
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        rejectApprovalItemsInBulk: function (id, axiosOptions) {
		            return localVarFp.rejectApprovalItemsInBulk(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API submits account selections. Either an admin, or the owning/current user must make this request.
		         * @summary Submit Account Selections
		         * @param {string} id The ID of the work item
		         * @param {{ [key: string]: any; }} requestBody Account Selection Data map, keyed on fieldName
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        submitAccountSelection: function (id, requestBody, axiosOptions) {
		            return localVarFp.submitAccountSelection(id, requestBody, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.WorkItemsBetaApiFactory = WorkItemsBetaApiFactory;
		/**
		 * WorkItemsBetaApi - object-oriented interface
		 * @export
		 * @class WorkItemsBetaApi
		 * @extends {BaseAPI}
		 */
		var WorkItemsBetaApi = /** @class */ (function (_super) {
		    __extends(WorkItemsBetaApi, _super);
		    function WorkItemsBetaApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * This API approves an Approval Item. Either an admin, or the owning/current user must make this request.
		     * @summary Approve an Approval Item
		     * @param {WorkItemsBetaApiApproveApprovalItemRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof WorkItemsBetaApi
		     */
		    WorkItemsBetaApi.prototype.approveApprovalItem = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.WorkItemsBetaApiFp)(this.configuration).approveApprovalItem(requestParameters.id, requestParameters.approvalItemId, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API bulk approves Approval Items. Either an admin, or the owning/current user must make this request.
		     * @summary Bulk approve Approval Items
		     * @param {WorkItemsBetaApiApproveApprovalItemsInBulkRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof WorkItemsBetaApi
		     */
		    WorkItemsBetaApi.prototype.approveApprovalItemsInBulk = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.WorkItemsBetaApiFp)(this.configuration).approveApprovalItemsInBulk(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API completes a work item. Either an admin, or the owning/current user must make this request.
		     * @summary Complete a Work Item
		     * @param {WorkItemsBetaApiCompleteWorkItemRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof WorkItemsBetaApi
		     */
		    WorkItemsBetaApi.prototype.completeWorkItem = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.WorkItemsBetaApiFp)(this.configuration).completeWorkItem(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API forwards a work item to a new owner. Either an admin, or the owning/current user must make this request.
		     * @summary Forward a Work Item
		     * @param {WorkItemsBetaApiForwardWorkItemRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof WorkItemsBetaApi
		     */
		    WorkItemsBetaApi.prototype.forwardWorkItem = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.WorkItemsBetaApiFp)(this.configuration).forwardWorkItem(requestParameters.id, requestParameters.workItemForwardBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This gets a collection of completed work items belonging to either the specified user(admin required), or the current user.
		     * @summary Completed Work Items
		     * @param {WorkItemsBetaApiGetCompletedWorkItemsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof WorkItemsBetaApi
		     */
		    WorkItemsBetaApi.prototype.getCompletedWorkItems = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.WorkItemsBetaApiFp)(this.configuration).getCompletedWorkItems(requestParameters.ownerId, requestParameters.limit, requestParameters.offset, requestParameters.count, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This gets a count of completed work items belonging to either the specified user(admin required), or the current user.
		     * @summary Count Completed Work Items
		     * @param {WorkItemsBetaApiGetCountCompletedWorkItemsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof WorkItemsBetaApi
		     */
		    WorkItemsBetaApi.prototype.getCountCompletedWorkItems = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.WorkItemsBetaApiFp)(this.configuration).getCountCompletedWorkItems(requestParameters.ownerId, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This gets a count of work items belonging to either the specified user(admin required), or the current user.
		     * @summary Count Work Items
		     * @param {WorkItemsBetaApiGetCountWorkItemsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof WorkItemsBetaApi
		     */
		    WorkItemsBetaApi.prototype.getCountWorkItems = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.WorkItemsBetaApiFp)(this.configuration).getCountWorkItems(requestParameters.ownerId, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This gets the details of a Work Item belonging to either the specified user(admin required), or the current user.
		     * @summary Get a Work Item
		     * @param {WorkItemsBetaApiGetWorkItemRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof WorkItemsBetaApi
		     */
		    WorkItemsBetaApi.prototype.getWorkItem = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.WorkItemsBetaApiFp)(this.configuration).getWorkItem(requestParameters.id, requestParameters.ownerId, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This gets a summary of work items belonging to either the specified user(admin required), or the current user.
		     * @summary Work Items Summary
		     * @param {WorkItemsBetaApiGetWorkItemsSummaryRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof WorkItemsBetaApi
		     */
		    WorkItemsBetaApi.prototype.getWorkItemsSummary = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.WorkItemsBetaApiFp)(this.configuration).getWorkItemsSummary(requestParameters.ownerId, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This gets a collection of work items belonging to either the specified user(admin required), or the current user.
		     * @summary List Work Items
		     * @param {WorkItemsBetaApiListWorkItemsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof WorkItemsBetaApi
		     */
		    WorkItemsBetaApi.prototype.listWorkItems = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.WorkItemsBetaApiFp)(this.configuration).listWorkItems(requestParameters.limit, requestParameters.offset, requestParameters.count, requestParameters.ownerId, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API rejects an Approval Item. Either an admin, or the owning/current user must make this request.
		     * @summary Reject an Approval Item
		     * @param {WorkItemsBetaApiRejectApprovalItemRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof WorkItemsBetaApi
		     */
		    WorkItemsBetaApi.prototype.rejectApprovalItem = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.WorkItemsBetaApiFp)(this.configuration).rejectApprovalItem(requestParameters.id, requestParameters.approvalItemId, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API bulk rejects Approval Items. Either an admin, or the owning/current user must make this request.
		     * @summary Bulk reject Approval Items
		     * @param {WorkItemsBetaApiRejectApprovalItemsInBulkRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof WorkItemsBetaApi
		     */
		    WorkItemsBetaApi.prototype.rejectApprovalItemsInBulk = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.WorkItemsBetaApiFp)(this.configuration).rejectApprovalItemsInBulk(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API submits account selections. Either an admin, or the owning/current user must make this request.
		     * @summary Submit Account Selections
		     * @param {WorkItemsBetaApiSubmitAccountSelectionRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof WorkItemsBetaApi
		     */
		    WorkItemsBetaApi.prototype.submitAccountSelection = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.WorkItemsBetaApiFp)(this.configuration).submitAccountSelection(requestParameters.id, requestParameters.requestBody, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return WorkItemsBetaApi;
		}(base_1.BaseAPI));
		exports.WorkItemsBetaApi = WorkItemsBetaApi;
		/**
		 * WorkReassignmentBetaApi - axios parameter creator
		 * @export
		 */
		var WorkReassignmentBetaApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * Creates a new Reassignment Configuration for the specified identity.
		         * @summary Create a Reassignment Configuration
		         * @param {ConfigurationItemRequestBeta} configurationItemRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createReassignmentConfiguration: function (configurationItemRequestBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'configurationItemRequestBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('createReassignmentConfiguration', 'configurationItemRequestBeta', configurationItemRequestBeta);
		                            localVarPath = "/reassignment-configurations";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(configurationItemRequestBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Deletes all Reassignment Configuration for the specified identity
		         * @summary Delete Reassignment Configuration
		         * @param {string} identityId unique identity id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteReassignmentConfiguration: function (identityId, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'identityId' is not null or undefined
		                            (0, common_1.assertParamExists)('deleteReassignmentConfiguration', 'identityId', identityId);
		                            localVarPath = "/reassignment-configurations/{identityId}"
		                                .replace("{".concat("identityId", "}"), encodeURIComponent(String(identityId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'DELETE' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Evaluates the Reassignment Configuration for an `Identity` to determine if work items for the specified type should be reassigned. If a valid Reassignment Configuration is found for the identity & work type, then a lookup is initiated which recursively fetches the Reassignment Configuration for the next `TargetIdentity` until no more results are found or a max depth of 5. That lookup trail is provided in the response and the final reassigned identity in the lookup list is returned as the `reassignToId` property. If no Reassignment Configuration is found for the specified identity & config type then the requested Identity ID will be used as the `reassignToId` value and the lookupTrail node will be empty.
		         * @summary Evaluate Reassignment Configuration
		         * @param {string} identityId unique identity id
		         * @param {ConfigTypeEnumBeta} configType Reassignment work type
		         * @param {Array<string>} [exclusionFilters] Exclusion filters that disable parts of the reassignment evaluation. Possible values are listed below: - &#x60;SELF_REVIEW_DELEGATION&#x60;: This will exclude delegations of self-review reassignments
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getEvaluateReassignmentConfiguration: function (identityId, configType, exclusionFilters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'identityId' is not null or undefined
		                            (0, common_1.assertParamExists)('getEvaluateReassignmentConfiguration', 'identityId', identityId);
		                            // verify required parameter 'configType' is not null or undefined
		                            (0, common_1.assertParamExists)('getEvaluateReassignmentConfiguration', 'configType', configType);
		                            localVarPath = "/reassignment-configurations/{identityId}/evaluate/{configType}"
		                                .replace("{".concat("identityId", "}"), encodeURIComponent(String(identityId)))
		                                .replace("{".concat("configType", "}"), encodeURIComponent(String(configType)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (exclusionFilters) {
		                                localVarQueryParameter['exclusionFilters'] = exclusionFilters.join(base_1.COLLECTION_FORMATS.csv);
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Gets a collection of types which are available in the Reassignment Configuration UI.
		         * @summary List Reassignment Config Types
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getReassignmentConfigTypes: function (axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/reassignment-configurations/types";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Gets the Reassignment Configuration for an identity.
		         * @summary Get Reassignment Configuration
		         * @param {string} identityId unique identity id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getReassignmentConfiguration: function (identityId, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'identityId' is not null or undefined
		                            (0, common_1.assertParamExists)('getReassignmentConfiguration', 'identityId', identityId);
		                            localVarPath = "/reassignment-configurations/{identityId}"
		                                .replace("{".concat("identityId", "}"), encodeURIComponent(String(identityId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Gets the global Reassignment Configuration settings for the requestor\'s tenant.
		         * @summary Get Tenant-wide Reassignment Configuration settings
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getTenantConfigConfiguration: function (axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/reassignment-configurations/tenant-config";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Gets all Reassignment configuration for the current org.
		         * @summary List Reassignment Configurations
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listReassignmentConfigurations: function (axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/reassignment-configurations";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Replaces existing Reassignment configuration for an identity with the newly provided configuration.
		         * @summary Update Reassignment Configuration
		         * @param {string} identityId unique identity id
		         * @param {ConfigurationItemRequestBeta} configurationItemRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putReassignmentConfig: function (identityId, configurationItemRequestBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'identityId' is not null or undefined
		                            (0, common_1.assertParamExists)('putReassignmentConfig', 'identityId', identityId);
		                            // verify required parameter 'configurationItemRequestBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('putReassignmentConfig', 'configurationItemRequestBeta', configurationItemRequestBeta);
		                            localVarPath = "/reassignment-configurations/{identityId}"
		                                .replace("{".concat("identityId", "}"), encodeURIComponent(String(identityId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PUT' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(configurationItemRequestBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Replaces existing Tenant-wide Reassignment Configuration settings with the newly provided settings.
		         * @summary Update Tenant-wide Reassignment Configuration settings
		         * @param {TenantConfigurationRequestBeta} tenantConfigurationRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putTenantConfiguration: function (tenantConfigurationRequestBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'tenantConfigurationRequestBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('putTenantConfiguration', 'tenantConfigurationRequestBeta', tenantConfigurationRequestBeta);
		                            localVarPath = "/reassignment-configurations/tenant-config";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PUT' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(tenantConfigurationRequestBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.WorkReassignmentBetaApiAxiosParamCreator = WorkReassignmentBetaApiAxiosParamCreator;
		/**
		 * WorkReassignmentBetaApi - functional programming interface
		 * @export
		 */
		var WorkReassignmentBetaApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.WorkReassignmentBetaApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * Creates a new Reassignment Configuration for the specified identity.
		         * @summary Create a Reassignment Configuration
		         * @param {ConfigurationItemRequestBeta} configurationItemRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createReassignmentConfiguration: function (configurationItemRequestBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.createReassignmentConfiguration(configurationItemRequestBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Deletes all Reassignment Configuration for the specified identity
		         * @summary Delete Reassignment Configuration
		         * @param {string} identityId unique identity id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteReassignmentConfiguration: function (identityId, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.deleteReassignmentConfiguration(identityId, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Evaluates the Reassignment Configuration for an `Identity` to determine if work items for the specified type should be reassigned. If a valid Reassignment Configuration is found for the identity & work type, then a lookup is initiated which recursively fetches the Reassignment Configuration for the next `TargetIdentity` until no more results are found or a max depth of 5. That lookup trail is provided in the response and the final reassigned identity in the lookup list is returned as the `reassignToId` property. If no Reassignment Configuration is found for the specified identity & config type then the requested Identity ID will be used as the `reassignToId` value and the lookupTrail node will be empty.
		         * @summary Evaluate Reassignment Configuration
		         * @param {string} identityId unique identity id
		         * @param {ConfigTypeEnumBeta} configType Reassignment work type
		         * @param {Array<string>} [exclusionFilters] Exclusion filters that disable parts of the reassignment evaluation. Possible values are listed below: - &#x60;SELF_REVIEW_DELEGATION&#x60;: This will exclude delegations of self-review reassignments
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getEvaluateReassignmentConfiguration: function (identityId, configType, exclusionFilters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getEvaluateReassignmentConfiguration(identityId, configType, exclusionFilters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Gets a collection of types which are available in the Reassignment Configuration UI.
		         * @summary List Reassignment Config Types
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getReassignmentConfigTypes: function (axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getReassignmentConfigTypes(axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Gets the Reassignment Configuration for an identity.
		         * @summary Get Reassignment Configuration
		         * @param {string} identityId unique identity id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getReassignmentConfiguration: function (identityId, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getReassignmentConfiguration(identityId, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Gets the global Reassignment Configuration settings for the requestor\'s tenant.
		         * @summary Get Tenant-wide Reassignment Configuration settings
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getTenantConfigConfiguration: function (axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getTenantConfigConfiguration(axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Gets all Reassignment configuration for the current org.
		         * @summary List Reassignment Configurations
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listReassignmentConfigurations: function (axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listReassignmentConfigurations(axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Replaces existing Reassignment configuration for an identity with the newly provided configuration.
		         * @summary Update Reassignment Configuration
		         * @param {string} identityId unique identity id
		         * @param {ConfigurationItemRequestBeta} configurationItemRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putReassignmentConfig: function (identityId, configurationItemRequestBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.putReassignmentConfig(identityId, configurationItemRequestBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Replaces existing Tenant-wide Reassignment Configuration settings with the newly provided settings.
		         * @summary Update Tenant-wide Reassignment Configuration settings
		         * @param {TenantConfigurationRequestBeta} tenantConfigurationRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putTenantConfiguration: function (tenantConfigurationRequestBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.putTenantConfiguration(tenantConfigurationRequestBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.WorkReassignmentBetaApiFp = WorkReassignmentBetaApiFp;
		/**
		 * WorkReassignmentBetaApi - factory interface
		 * @export
		 */
		var WorkReassignmentBetaApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.WorkReassignmentBetaApiFp)(configuration);
		    return {
		        /**
		         * Creates a new Reassignment Configuration for the specified identity.
		         * @summary Create a Reassignment Configuration
		         * @param {ConfigurationItemRequestBeta} configurationItemRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createReassignmentConfiguration: function (configurationItemRequestBeta, axiosOptions) {
		            return localVarFp.createReassignmentConfiguration(configurationItemRequestBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Deletes all Reassignment Configuration for the specified identity
		         * @summary Delete Reassignment Configuration
		         * @param {string} identityId unique identity id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteReassignmentConfiguration: function (identityId, axiosOptions) {
		            return localVarFp.deleteReassignmentConfiguration(identityId, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Evaluates the Reassignment Configuration for an `Identity` to determine if work items for the specified type should be reassigned. If a valid Reassignment Configuration is found for the identity & work type, then a lookup is initiated which recursively fetches the Reassignment Configuration for the next `TargetIdentity` until no more results are found or a max depth of 5. That lookup trail is provided in the response and the final reassigned identity in the lookup list is returned as the `reassignToId` property. If no Reassignment Configuration is found for the specified identity & config type then the requested Identity ID will be used as the `reassignToId` value and the lookupTrail node will be empty.
		         * @summary Evaluate Reassignment Configuration
		         * @param {string} identityId unique identity id
		         * @param {ConfigTypeEnumBeta} configType Reassignment work type
		         * @param {Array<string>} [exclusionFilters] Exclusion filters that disable parts of the reassignment evaluation. Possible values are listed below: - &#x60;SELF_REVIEW_DELEGATION&#x60;: This will exclude delegations of self-review reassignments
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getEvaluateReassignmentConfiguration: function (identityId, configType, exclusionFilters, axiosOptions) {
		            return localVarFp.getEvaluateReassignmentConfiguration(identityId, configType, exclusionFilters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Gets a collection of types which are available in the Reassignment Configuration UI.
		         * @summary List Reassignment Config Types
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getReassignmentConfigTypes: function (axiosOptions) {
		            return localVarFp.getReassignmentConfigTypes(axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Gets the Reassignment Configuration for an identity.
		         * @summary Get Reassignment Configuration
		         * @param {string} identityId unique identity id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getReassignmentConfiguration: function (identityId, axiosOptions) {
		            return localVarFp.getReassignmentConfiguration(identityId, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Gets the global Reassignment Configuration settings for the requestor\'s tenant.
		         * @summary Get Tenant-wide Reassignment Configuration settings
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getTenantConfigConfiguration: function (axiosOptions) {
		            return localVarFp.getTenantConfigConfiguration(axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Gets all Reassignment configuration for the current org.
		         * @summary List Reassignment Configurations
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listReassignmentConfigurations: function (axiosOptions) {
		            return localVarFp.listReassignmentConfigurations(axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Replaces existing Reassignment configuration for an identity with the newly provided configuration.
		         * @summary Update Reassignment Configuration
		         * @param {string} identityId unique identity id
		         * @param {ConfigurationItemRequestBeta} configurationItemRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putReassignmentConfig: function (identityId, configurationItemRequestBeta, axiosOptions) {
		            return localVarFp.putReassignmentConfig(identityId, configurationItemRequestBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Replaces existing Tenant-wide Reassignment Configuration settings with the newly provided settings.
		         * @summary Update Tenant-wide Reassignment Configuration settings
		         * @param {TenantConfigurationRequestBeta} tenantConfigurationRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putTenantConfiguration: function (tenantConfigurationRequestBeta, axiosOptions) {
		            return localVarFp.putTenantConfiguration(tenantConfigurationRequestBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.WorkReassignmentBetaApiFactory = WorkReassignmentBetaApiFactory;
		/**
		 * WorkReassignmentBetaApi - object-oriented interface
		 * @export
		 * @class WorkReassignmentBetaApi
		 * @extends {BaseAPI}
		 */
		var WorkReassignmentBetaApi = /** @class */ (function (_super) {
		    __extends(WorkReassignmentBetaApi, _super);
		    function WorkReassignmentBetaApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * Creates a new Reassignment Configuration for the specified identity.
		     * @summary Create a Reassignment Configuration
		     * @param {WorkReassignmentBetaApiCreateReassignmentConfigurationRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof WorkReassignmentBetaApi
		     */
		    WorkReassignmentBetaApi.prototype.createReassignmentConfiguration = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.WorkReassignmentBetaApiFp)(this.configuration).createReassignmentConfiguration(requestParameters.configurationItemRequestBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Deletes all Reassignment Configuration for the specified identity
		     * @summary Delete Reassignment Configuration
		     * @param {WorkReassignmentBetaApiDeleteReassignmentConfigurationRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof WorkReassignmentBetaApi
		     */
		    WorkReassignmentBetaApi.prototype.deleteReassignmentConfiguration = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.WorkReassignmentBetaApiFp)(this.configuration).deleteReassignmentConfiguration(requestParameters.identityId, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Evaluates the Reassignment Configuration for an `Identity` to determine if work items for the specified type should be reassigned. If a valid Reassignment Configuration is found for the identity & work type, then a lookup is initiated which recursively fetches the Reassignment Configuration for the next `TargetIdentity` until no more results are found or a max depth of 5. That lookup trail is provided in the response and the final reassigned identity in the lookup list is returned as the `reassignToId` property. If no Reassignment Configuration is found for the specified identity & config type then the requested Identity ID will be used as the `reassignToId` value and the lookupTrail node will be empty.
		     * @summary Evaluate Reassignment Configuration
		     * @param {WorkReassignmentBetaApiGetEvaluateReassignmentConfigurationRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof WorkReassignmentBetaApi
		     */
		    WorkReassignmentBetaApi.prototype.getEvaluateReassignmentConfiguration = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.WorkReassignmentBetaApiFp)(this.configuration).getEvaluateReassignmentConfiguration(requestParameters.identityId, requestParameters.configType, requestParameters.exclusionFilters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Gets a collection of types which are available in the Reassignment Configuration UI.
		     * @summary List Reassignment Config Types
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof WorkReassignmentBetaApi
		     */
		    WorkReassignmentBetaApi.prototype.getReassignmentConfigTypes = function (axiosOptions) {
		        var _this = this;
		        return (0, exports.WorkReassignmentBetaApiFp)(this.configuration).getReassignmentConfigTypes(axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Gets the Reassignment Configuration for an identity.
		     * @summary Get Reassignment Configuration
		     * @param {WorkReassignmentBetaApiGetReassignmentConfigurationRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof WorkReassignmentBetaApi
		     */
		    WorkReassignmentBetaApi.prototype.getReassignmentConfiguration = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.WorkReassignmentBetaApiFp)(this.configuration).getReassignmentConfiguration(requestParameters.identityId, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Gets the global Reassignment Configuration settings for the requestor\'s tenant.
		     * @summary Get Tenant-wide Reassignment Configuration settings
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof WorkReassignmentBetaApi
		     */
		    WorkReassignmentBetaApi.prototype.getTenantConfigConfiguration = function (axiosOptions) {
		        var _this = this;
		        return (0, exports.WorkReassignmentBetaApiFp)(this.configuration).getTenantConfigConfiguration(axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Gets all Reassignment configuration for the current org.
		     * @summary List Reassignment Configurations
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof WorkReassignmentBetaApi
		     */
		    WorkReassignmentBetaApi.prototype.listReassignmentConfigurations = function (axiosOptions) {
		        var _this = this;
		        return (0, exports.WorkReassignmentBetaApiFp)(this.configuration).listReassignmentConfigurations(axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Replaces existing Reassignment configuration for an identity with the newly provided configuration.
		     * @summary Update Reassignment Configuration
		     * @param {WorkReassignmentBetaApiPutReassignmentConfigRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof WorkReassignmentBetaApi
		     */
		    WorkReassignmentBetaApi.prototype.putReassignmentConfig = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.WorkReassignmentBetaApiFp)(this.configuration).putReassignmentConfig(requestParameters.identityId, requestParameters.configurationItemRequestBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Replaces existing Tenant-wide Reassignment Configuration settings with the newly provided settings.
		     * @summary Update Tenant-wide Reassignment Configuration settings
		     * @param {WorkReassignmentBetaApiPutTenantConfigurationRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof WorkReassignmentBetaApi
		     */
		    WorkReassignmentBetaApi.prototype.putTenantConfiguration = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.WorkReassignmentBetaApiFp)(this.configuration).putTenantConfiguration(requestParameters.tenantConfigurationRequestBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return WorkReassignmentBetaApi;
		}(base_1.BaseAPI));
		exports.WorkReassignmentBetaApi = WorkReassignmentBetaApi;
		/**
		 * WorkflowsBetaApi - axios parameter creator
		 * @export
		 */
		var WorkflowsBetaApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * Use this API to cancel a running workflow execution.
		         * @summary Cancel Workflow Execution by ID
		         * @param {string} id The workflow execution ID
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        cancelWorkflowExecution: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('cancelWorkflowExecution', 'id', id);
		                            localVarPath = "/workflow-executions/{id}/cancel"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Create a new workflow with the desired trigger and steps specified in the request body.
		         * @summary Create Workflow
		         * @param {CreateWorkflowRequestBeta} createWorkflowRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createWorkflow: function (createWorkflowRequestBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'createWorkflowRequestBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('createWorkflow', 'createWorkflowRequestBeta', createWorkflowRequestBeta);
		                            localVarPath = "/workflows";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(createWorkflowRequestBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Delete a workflow.  **Enabled workflows cannot be deleted**.  They must first be disabled.
		         * @summary Delete Workflow By Id
		         * @param {string} id Id of the Workflow
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteWorkflow: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('deleteWorkflow', 'id', id);
		                            localVarPath = "/workflows/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'DELETE' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Get a single workflow by id.
		         * @summary Get Workflow By Id
		         * @param {string} id Id of the workflow
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getWorkflow: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getWorkflow', 'id', id);
		                            localVarPath = "/workflows/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Get a single workflow execution.  Workflow executions are available for up to 90 days before being archived.  If you attempt to access a workflow execution that has been archived, you will receive a 404 Not Found.
		         * @summary Get a Workflow Execution
		         * @param {string} id Id of the workflow execution
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getWorkflowExecution: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getWorkflowExecution', 'id', id);
		                            localVarPath = "/workflow-executions/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Get a detailed history of a single workflow execution.  Workflow executions are available for up to 90 days before being archived.  If you attempt to access a workflow execution that has been archived, you will receive a 404 Not Found.
		         * @summary Get Workflow Execution History
		         * @param {string} id Id of the workflow execution
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getWorkflowExecutionHistory: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getWorkflowExecutionHistory', 'id', id);
		                            localVarPath = "/workflow-executions/{id}/history"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This lists all triggers, actions, and operators in the library
		         * @summary List Complete Workflow Library
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listCompleteWorkflowLibrary: function (limit, offset, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/workflow-library";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This lists the executions for a given workflow. Workflow executions are available for up to 90 days before being archived. By default, you can get a maximum of 250 executions.  To get executions past the first 250 records, you can do the following:  1. Use the [Get Workflows](https://developer.sailpoint.com/idn/api/beta/list-workflows) endpoint to get your workflows.  2. Get your workflow ID from the response.  3. You can then do either of the following:     - Filter to find relevant workflow executions.   For example, you can filter for failed workflow executions: `GET /workflows/:workflowID/executions?filters=status eq \"Failed\"`    - You can paginate through results with the `offset` parameter.    For example, you can page through 50 executions per page and use that as a way to get to the records past the first 250.    Refer to [Paginating Results](https://developer.sailpoint.com/idn/api/standard-collection-parameters#paginating-results) for more information about the query parameters you can use to achieve pagination.
		         * @summary List Workflow Executions
		         * @param {string} id Id of the workflow
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **startTime**: *eq, lt, le, gt, ge*  **status**: *eq*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listWorkflowExecutions: function (id, limit, offset, count, filters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('listWorkflowExecutions', 'id', id);
		                            localVarPath = "/workflows/{id}/executions"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This lists the workflow actions available to you.
		         * @summary List Workflow Library Actions
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listWorkflowLibraryActions: function (limit, offset, filters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/workflow-library/actions";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This lists the workflow operators available to you
		         * @summary List Workflow Library Operators
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listWorkflowLibraryOperators: function (axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/workflow-library/operators";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This lists the workflow triggers available to you
		         * @summary List Workflow Library Triggers
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listWorkflowLibraryTriggers: function (limit, offset, filters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/workflow-library/triggers";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * List all workflows in the tenant.
		         * @summary List Workflows
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listWorkflows: function (axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/workflows";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Partially update an existing Workflow using [JSON Patch](https://tools.ietf.org/html/rfc6902) syntax.
		         * @summary Patch Workflow
		         * @param {string} id Id of the Workflow
		         * @param {Array<JsonPatchOperationBeta>} jsonPatchOperationBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchWorkflow: function (id, jsonPatchOperationBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('patchWorkflow', 'id', id);
		                            // verify required parameter 'jsonPatchOperationBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('patchWorkflow', 'jsonPatchOperationBeta', jsonPatchOperationBeta);
		                            localVarPath = "/workflows/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PATCH' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json-patch+json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(jsonPatchOperationBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This endpoint allows a service outside of IdentityNow to initiate a workflow that uses the \"External Trigger\" step.  The external service will invoke this endpoint with the input data it wants to send to the workflow in the body.
		         * @summary Execute Workflow via External Trigger
		         * @param {string} id Id of the workflow
		         * @param {PostExternalExecuteWorkflowRequestBeta} [postExternalExecuteWorkflowRequestBeta]
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        postExternalExecuteWorkflow: function (id, postExternalExecuteWorkflowRequestBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('postExternalExecuteWorkflow', 'id', id);
		                            localVarPath = "/workflows/execute/external/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(postExternalExecuteWorkflowRequestBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Create OAuth client ID, client secret, and callback URL for use in an external trigger.  External triggers will need this information to generate an access token to authenticate to the callback URL and submit a trigger payload that will initiate the workflow.
		         * @summary Generate External Trigger OAuth Client
		         * @param {string} id Id of the workflow
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        postWorkflowExternalTrigger: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('postWorkflowExternalTrigger', 'id', id);
		                            localVarPath = "/workflows/{id}/external/oauth-clients"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Validate a workflow with an \"External Trigger\" can receive input.  The response includes the input that the workflow received, which can be used to validate that the input is intact when it reaches the workflow.
		         * @summary Test Workflow via External Trigger
		         * @param {string} id Id of the workflow
		         * @param {TestExternalExecuteWorkflowRequestBeta} [testExternalExecuteWorkflowRequestBeta]
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        testExternalExecuteWorkflow: function (id, testExternalExecuteWorkflowRequestBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('testExternalExecuteWorkflow', 'id', id);
		                            localVarPath = "/workflows/execute/external/{id}/test"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(testExternalExecuteWorkflowRequestBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Test a workflow with the provided input data.  The input data should resemble the input that the trigger will send the workflow.  See the [event trigger documentation](https://developer.sailpoint.com/idn/docs/event-triggers/available) for an example input for the trigger that initiates this workflow. This endpoint will return an execution ID, which can be used to lookup more information about the execution using the `Get a Workflow Execution` endpoint. **This will cause a live run of the workflow, which could result in unintended modifications to your IDN tenant.**
		         * @summary Test Workflow By Id
		         * @param {string} id Id of the workflow
		         * @param {TestWorkflowRequestBeta} testWorkflowRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        testWorkflow: function (id, testWorkflowRequestBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('testWorkflow', 'id', id);
		                            // verify required parameter 'testWorkflowRequestBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('testWorkflow', 'testWorkflowRequestBeta', testWorkflowRequestBeta);
		                            localVarPath = "/workflows/{id}/test"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(testWorkflowRequestBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Perform a full update of a workflow.  The updated workflow object is returned in the response.
		         * @summary Update Workflow
		         * @param {string} id Id of the Workflow
		         * @param {WorkflowBodyBeta} workflowBodyBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateWorkflow: function (id, workflowBodyBeta, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('updateWorkflow', 'id', id);
		                            // verify required parameter 'workflowBodyBeta' is not null or undefined
		                            (0, common_1.assertParamExists)('updateWorkflow', 'workflowBodyBeta', workflowBodyBeta);
		                            localVarPath = "/workflows/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PUT' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(workflowBodyBeta, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.WorkflowsBetaApiAxiosParamCreator = WorkflowsBetaApiAxiosParamCreator;
		/**
		 * WorkflowsBetaApi - functional programming interface
		 * @export
		 */
		var WorkflowsBetaApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.WorkflowsBetaApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * Use this API to cancel a running workflow execution.
		         * @summary Cancel Workflow Execution by ID
		         * @param {string} id The workflow execution ID
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        cancelWorkflowExecution: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.cancelWorkflowExecution(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Create a new workflow with the desired trigger and steps specified in the request body.
		         * @summary Create Workflow
		         * @param {CreateWorkflowRequestBeta} createWorkflowRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createWorkflow: function (createWorkflowRequestBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.createWorkflow(createWorkflowRequestBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Delete a workflow.  **Enabled workflows cannot be deleted**.  They must first be disabled.
		         * @summary Delete Workflow By Id
		         * @param {string} id Id of the Workflow
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteWorkflow: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.deleteWorkflow(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Get a single workflow by id.
		         * @summary Get Workflow By Id
		         * @param {string} id Id of the workflow
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getWorkflow: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getWorkflow(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Get a single workflow execution.  Workflow executions are available for up to 90 days before being archived.  If you attempt to access a workflow execution that has been archived, you will receive a 404 Not Found.
		         * @summary Get a Workflow Execution
		         * @param {string} id Id of the workflow execution
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getWorkflowExecution: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getWorkflowExecution(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Get a detailed history of a single workflow execution.  Workflow executions are available for up to 90 days before being archived.  If you attempt to access a workflow execution that has been archived, you will receive a 404 Not Found.
		         * @summary Get Workflow Execution History
		         * @param {string} id Id of the workflow execution
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getWorkflowExecutionHistory: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getWorkflowExecutionHistory(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This lists all triggers, actions, and operators in the library
		         * @summary List Complete Workflow Library
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listCompleteWorkflowLibrary: function (limit, offset, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listCompleteWorkflowLibrary(limit, offset, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This lists the executions for a given workflow. Workflow executions are available for up to 90 days before being archived. By default, you can get a maximum of 250 executions.  To get executions past the first 250 records, you can do the following:  1. Use the [Get Workflows](https://developer.sailpoint.com/idn/api/beta/list-workflows) endpoint to get your workflows.  2. Get your workflow ID from the response.  3. You can then do either of the following:     - Filter to find relevant workflow executions.   For example, you can filter for failed workflow executions: `GET /workflows/:workflowID/executions?filters=status eq \"Failed\"`    - You can paginate through results with the `offset` parameter.    For example, you can page through 50 executions per page and use that as a way to get to the records past the first 250.    Refer to [Paginating Results](https://developer.sailpoint.com/idn/api/standard-collection-parameters#paginating-results) for more information about the query parameters you can use to achieve pagination.
		         * @summary List Workflow Executions
		         * @param {string} id Id of the workflow
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **startTime**: *eq, lt, le, gt, ge*  **status**: *eq*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listWorkflowExecutions: function (id, limit, offset, count, filters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listWorkflowExecutions(id, limit, offset, count, filters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This lists the workflow actions available to you.
		         * @summary List Workflow Library Actions
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listWorkflowLibraryActions: function (limit, offset, filters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listWorkflowLibraryActions(limit, offset, filters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This lists the workflow operators available to you
		         * @summary List Workflow Library Operators
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listWorkflowLibraryOperators: function (axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listWorkflowLibraryOperators(axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This lists the workflow triggers available to you
		         * @summary List Workflow Library Triggers
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listWorkflowLibraryTriggers: function (limit, offset, filters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listWorkflowLibraryTriggers(limit, offset, filters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * List all workflows in the tenant.
		         * @summary List Workflows
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listWorkflows: function (axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listWorkflows(axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Partially update an existing Workflow using [JSON Patch](https://tools.ietf.org/html/rfc6902) syntax.
		         * @summary Patch Workflow
		         * @param {string} id Id of the Workflow
		         * @param {Array<JsonPatchOperationBeta>} jsonPatchOperationBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchWorkflow: function (id, jsonPatchOperationBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.patchWorkflow(id, jsonPatchOperationBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This endpoint allows a service outside of IdentityNow to initiate a workflow that uses the \"External Trigger\" step.  The external service will invoke this endpoint with the input data it wants to send to the workflow in the body.
		         * @summary Execute Workflow via External Trigger
		         * @param {string} id Id of the workflow
		         * @param {PostExternalExecuteWorkflowRequestBeta} [postExternalExecuteWorkflowRequestBeta]
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        postExternalExecuteWorkflow: function (id, postExternalExecuteWorkflowRequestBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.postExternalExecuteWorkflow(id, postExternalExecuteWorkflowRequestBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Create OAuth client ID, client secret, and callback URL for use in an external trigger.  External triggers will need this information to generate an access token to authenticate to the callback URL and submit a trigger payload that will initiate the workflow.
		         * @summary Generate External Trigger OAuth Client
		         * @param {string} id Id of the workflow
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        postWorkflowExternalTrigger: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.postWorkflowExternalTrigger(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Validate a workflow with an \"External Trigger\" can receive input.  The response includes the input that the workflow received, which can be used to validate that the input is intact when it reaches the workflow.
		         * @summary Test Workflow via External Trigger
		         * @param {string} id Id of the workflow
		         * @param {TestExternalExecuteWorkflowRequestBeta} [testExternalExecuteWorkflowRequestBeta]
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        testExternalExecuteWorkflow: function (id, testExternalExecuteWorkflowRequestBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.testExternalExecuteWorkflow(id, testExternalExecuteWorkflowRequestBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Test a workflow with the provided input data.  The input data should resemble the input that the trigger will send the workflow.  See the [event trigger documentation](https://developer.sailpoint.com/idn/docs/event-triggers/available) for an example input for the trigger that initiates this workflow. This endpoint will return an execution ID, which can be used to lookup more information about the execution using the `Get a Workflow Execution` endpoint. **This will cause a live run of the workflow, which could result in unintended modifications to your IDN tenant.**
		         * @summary Test Workflow By Id
		         * @param {string} id Id of the workflow
		         * @param {TestWorkflowRequestBeta} testWorkflowRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        testWorkflow: function (id, testWorkflowRequestBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.testWorkflow(id, testWorkflowRequestBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Perform a full update of a workflow.  The updated workflow object is returned in the response.
		         * @summary Update Workflow
		         * @param {string} id Id of the Workflow
		         * @param {WorkflowBodyBeta} workflowBodyBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateWorkflow: function (id, workflowBodyBeta, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.updateWorkflow(id, workflowBodyBeta, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.WorkflowsBetaApiFp = WorkflowsBetaApiFp;
		/**
		 * WorkflowsBetaApi - factory interface
		 * @export
		 */
		var WorkflowsBetaApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.WorkflowsBetaApiFp)(configuration);
		    return {
		        /**
		         * Use this API to cancel a running workflow execution.
		         * @summary Cancel Workflow Execution by ID
		         * @param {string} id The workflow execution ID
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        cancelWorkflowExecution: function (id, axiosOptions) {
		            return localVarFp.cancelWorkflowExecution(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Create a new workflow with the desired trigger and steps specified in the request body.
		         * @summary Create Workflow
		         * @param {CreateWorkflowRequestBeta} createWorkflowRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createWorkflow: function (createWorkflowRequestBeta, axiosOptions) {
		            return localVarFp.createWorkflow(createWorkflowRequestBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Delete a workflow.  **Enabled workflows cannot be deleted**.  They must first be disabled.
		         * @summary Delete Workflow By Id
		         * @param {string} id Id of the Workflow
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteWorkflow: function (id, axiosOptions) {
		            return localVarFp.deleteWorkflow(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Get a single workflow by id.
		         * @summary Get Workflow By Id
		         * @param {string} id Id of the workflow
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getWorkflow: function (id, axiosOptions) {
		            return localVarFp.getWorkflow(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Get a single workflow execution.  Workflow executions are available for up to 90 days before being archived.  If you attempt to access a workflow execution that has been archived, you will receive a 404 Not Found.
		         * @summary Get a Workflow Execution
		         * @param {string} id Id of the workflow execution
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getWorkflowExecution: function (id, axiosOptions) {
		            return localVarFp.getWorkflowExecution(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Get a detailed history of a single workflow execution.  Workflow executions are available for up to 90 days before being archived.  If you attempt to access a workflow execution that has been archived, you will receive a 404 Not Found.
		         * @summary Get Workflow Execution History
		         * @param {string} id Id of the workflow execution
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getWorkflowExecutionHistory: function (id, axiosOptions) {
		            return localVarFp.getWorkflowExecutionHistory(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This lists all triggers, actions, and operators in the library
		         * @summary List Complete Workflow Library
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listCompleteWorkflowLibrary: function (limit, offset, axiosOptions) {
		            return localVarFp.listCompleteWorkflowLibrary(limit, offset, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This lists the executions for a given workflow. Workflow executions are available for up to 90 days before being archived. By default, you can get a maximum of 250 executions.  To get executions past the first 250 records, you can do the following:  1. Use the [Get Workflows](https://developer.sailpoint.com/idn/api/beta/list-workflows) endpoint to get your workflows.  2. Get your workflow ID from the response.  3. You can then do either of the following:     - Filter to find relevant workflow executions.   For example, you can filter for failed workflow executions: `GET /workflows/:workflowID/executions?filters=status eq \"Failed\"`    - You can paginate through results with the `offset` parameter.    For example, you can page through 50 executions per page and use that as a way to get to the records past the first 250.    Refer to [Paginating Results](https://developer.sailpoint.com/idn/api/standard-collection-parameters#paginating-results) for more information about the query parameters you can use to achieve pagination.
		         * @summary List Workflow Executions
		         * @param {string} id Id of the workflow
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **startTime**: *eq, lt, le, gt, ge*  **status**: *eq*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listWorkflowExecutions: function (id, limit, offset, count, filters, axiosOptions) {
		            return localVarFp.listWorkflowExecutions(id, limit, offset, count, filters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This lists the workflow actions available to you.
		         * @summary List Workflow Library Actions
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listWorkflowLibraryActions: function (limit, offset, filters, axiosOptions) {
		            return localVarFp.listWorkflowLibraryActions(limit, offset, filters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This lists the workflow operators available to you
		         * @summary List Workflow Library Operators
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listWorkflowLibraryOperators: function (axiosOptions) {
		            return localVarFp.listWorkflowLibraryOperators(axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This lists the workflow triggers available to you
		         * @summary List Workflow Library Triggers
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listWorkflowLibraryTriggers: function (limit, offset, filters, axiosOptions) {
		            return localVarFp.listWorkflowLibraryTriggers(limit, offset, filters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * List all workflows in the tenant.
		         * @summary List Workflows
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listWorkflows: function (axiosOptions) {
		            return localVarFp.listWorkflows(axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Partially update an existing Workflow using [JSON Patch](https://tools.ietf.org/html/rfc6902) syntax.
		         * @summary Patch Workflow
		         * @param {string} id Id of the Workflow
		         * @param {Array<JsonPatchOperationBeta>} jsonPatchOperationBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchWorkflow: function (id, jsonPatchOperationBeta, axiosOptions) {
		            return localVarFp.patchWorkflow(id, jsonPatchOperationBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This endpoint allows a service outside of IdentityNow to initiate a workflow that uses the \"External Trigger\" step.  The external service will invoke this endpoint with the input data it wants to send to the workflow in the body.
		         * @summary Execute Workflow via External Trigger
		         * @param {string} id Id of the workflow
		         * @param {PostExternalExecuteWorkflowRequestBeta} [postExternalExecuteWorkflowRequestBeta]
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        postExternalExecuteWorkflow: function (id, postExternalExecuteWorkflowRequestBeta, axiosOptions) {
		            return localVarFp.postExternalExecuteWorkflow(id, postExternalExecuteWorkflowRequestBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Create OAuth client ID, client secret, and callback URL for use in an external trigger.  External triggers will need this information to generate an access token to authenticate to the callback URL and submit a trigger payload that will initiate the workflow.
		         * @summary Generate External Trigger OAuth Client
		         * @param {string} id Id of the workflow
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        postWorkflowExternalTrigger: function (id, axiosOptions) {
		            return localVarFp.postWorkflowExternalTrigger(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Validate a workflow with an \"External Trigger\" can receive input.  The response includes the input that the workflow received, which can be used to validate that the input is intact when it reaches the workflow.
		         * @summary Test Workflow via External Trigger
		         * @param {string} id Id of the workflow
		         * @param {TestExternalExecuteWorkflowRequestBeta} [testExternalExecuteWorkflowRequestBeta]
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        testExternalExecuteWorkflow: function (id, testExternalExecuteWorkflowRequestBeta, axiosOptions) {
		            return localVarFp.testExternalExecuteWorkflow(id, testExternalExecuteWorkflowRequestBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Test a workflow with the provided input data.  The input data should resemble the input that the trigger will send the workflow.  See the [event trigger documentation](https://developer.sailpoint.com/idn/docs/event-triggers/available) for an example input for the trigger that initiates this workflow. This endpoint will return an execution ID, which can be used to lookup more information about the execution using the `Get a Workflow Execution` endpoint. **This will cause a live run of the workflow, which could result in unintended modifications to your IDN tenant.**
		         * @summary Test Workflow By Id
		         * @param {string} id Id of the workflow
		         * @param {TestWorkflowRequestBeta} testWorkflowRequestBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        testWorkflow: function (id, testWorkflowRequestBeta, axiosOptions) {
		            return localVarFp.testWorkflow(id, testWorkflowRequestBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Perform a full update of a workflow.  The updated workflow object is returned in the response.
		         * @summary Update Workflow
		         * @param {string} id Id of the Workflow
		         * @param {WorkflowBodyBeta} workflowBodyBeta
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateWorkflow: function (id, workflowBodyBeta, axiosOptions) {
		            return localVarFp.updateWorkflow(id, workflowBodyBeta, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.WorkflowsBetaApiFactory = WorkflowsBetaApiFactory;
		/**
		 * WorkflowsBetaApi - object-oriented interface
		 * @export
		 * @class WorkflowsBetaApi
		 * @extends {BaseAPI}
		 */
		var WorkflowsBetaApi = /** @class */ (function (_super) {
		    __extends(WorkflowsBetaApi, _super);
		    function WorkflowsBetaApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * Use this API to cancel a running workflow execution.
		     * @summary Cancel Workflow Execution by ID
		     * @param {WorkflowsBetaApiCancelWorkflowExecutionRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof WorkflowsBetaApi
		     */
		    WorkflowsBetaApi.prototype.cancelWorkflowExecution = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.WorkflowsBetaApiFp)(this.configuration).cancelWorkflowExecution(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Create a new workflow with the desired trigger and steps specified in the request body.
		     * @summary Create Workflow
		     * @param {WorkflowsBetaApiCreateWorkflowRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof WorkflowsBetaApi
		     */
		    WorkflowsBetaApi.prototype.createWorkflow = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.WorkflowsBetaApiFp)(this.configuration).createWorkflow(requestParameters.createWorkflowRequestBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Delete a workflow.  **Enabled workflows cannot be deleted**.  They must first be disabled.
		     * @summary Delete Workflow By Id
		     * @param {WorkflowsBetaApiDeleteWorkflowRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof WorkflowsBetaApi
		     */
		    WorkflowsBetaApi.prototype.deleteWorkflow = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.WorkflowsBetaApiFp)(this.configuration).deleteWorkflow(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Get a single workflow by id.
		     * @summary Get Workflow By Id
		     * @param {WorkflowsBetaApiGetWorkflowRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof WorkflowsBetaApi
		     */
		    WorkflowsBetaApi.prototype.getWorkflow = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.WorkflowsBetaApiFp)(this.configuration).getWorkflow(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Get a single workflow execution.  Workflow executions are available for up to 90 days before being archived.  If you attempt to access a workflow execution that has been archived, you will receive a 404 Not Found.
		     * @summary Get a Workflow Execution
		     * @param {WorkflowsBetaApiGetWorkflowExecutionRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof WorkflowsBetaApi
		     */
		    WorkflowsBetaApi.prototype.getWorkflowExecution = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.WorkflowsBetaApiFp)(this.configuration).getWorkflowExecution(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Get a detailed history of a single workflow execution.  Workflow executions are available for up to 90 days before being archived.  If you attempt to access a workflow execution that has been archived, you will receive a 404 Not Found.
		     * @summary Get Workflow Execution History
		     * @param {WorkflowsBetaApiGetWorkflowExecutionHistoryRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof WorkflowsBetaApi
		     */
		    WorkflowsBetaApi.prototype.getWorkflowExecutionHistory = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.WorkflowsBetaApiFp)(this.configuration).getWorkflowExecutionHistory(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This lists all triggers, actions, and operators in the library
		     * @summary List Complete Workflow Library
		     * @param {WorkflowsBetaApiListCompleteWorkflowLibraryRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof WorkflowsBetaApi
		     */
		    WorkflowsBetaApi.prototype.listCompleteWorkflowLibrary = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.WorkflowsBetaApiFp)(this.configuration).listCompleteWorkflowLibrary(requestParameters.limit, requestParameters.offset, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This lists the executions for a given workflow. Workflow executions are available for up to 90 days before being archived. By default, you can get a maximum of 250 executions.  To get executions past the first 250 records, you can do the following:  1. Use the [Get Workflows](https://developer.sailpoint.com/idn/api/beta/list-workflows) endpoint to get your workflows.  2. Get your workflow ID from the response.  3. You can then do either of the following:     - Filter to find relevant workflow executions.   For example, you can filter for failed workflow executions: `GET /workflows/:workflowID/executions?filters=status eq \"Failed\"`    - You can paginate through results with the `offset` parameter.    For example, you can page through 50 executions per page and use that as a way to get to the records past the first 250.    Refer to [Paginating Results](https://developer.sailpoint.com/idn/api/standard-collection-parameters#paginating-results) for more information about the query parameters you can use to achieve pagination.
		     * @summary List Workflow Executions
		     * @param {WorkflowsBetaApiListWorkflowExecutionsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof WorkflowsBetaApi
		     */
		    WorkflowsBetaApi.prototype.listWorkflowExecutions = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.WorkflowsBetaApiFp)(this.configuration).listWorkflowExecutions(requestParameters.id, requestParameters.limit, requestParameters.offset, requestParameters.count, requestParameters.filters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This lists the workflow actions available to you.
		     * @summary List Workflow Library Actions
		     * @param {WorkflowsBetaApiListWorkflowLibraryActionsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof WorkflowsBetaApi
		     */
		    WorkflowsBetaApi.prototype.listWorkflowLibraryActions = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.WorkflowsBetaApiFp)(this.configuration).listWorkflowLibraryActions(requestParameters.limit, requestParameters.offset, requestParameters.filters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This lists the workflow operators available to you
		     * @summary List Workflow Library Operators
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof WorkflowsBetaApi
		     */
		    WorkflowsBetaApi.prototype.listWorkflowLibraryOperators = function (axiosOptions) {
		        var _this = this;
		        return (0, exports.WorkflowsBetaApiFp)(this.configuration).listWorkflowLibraryOperators(axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This lists the workflow triggers available to you
		     * @summary List Workflow Library Triggers
		     * @param {WorkflowsBetaApiListWorkflowLibraryTriggersRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof WorkflowsBetaApi
		     */
		    WorkflowsBetaApi.prototype.listWorkflowLibraryTriggers = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.WorkflowsBetaApiFp)(this.configuration).listWorkflowLibraryTriggers(requestParameters.limit, requestParameters.offset, requestParameters.filters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * List all workflows in the tenant.
		     * @summary List Workflows
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof WorkflowsBetaApi
		     */
		    WorkflowsBetaApi.prototype.listWorkflows = function (axiosOptions) {
		        var _this = this;
		        return (0, exports.WorkflowsBetaApiFp)(this.configuration).listWorkflows(axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Partially update an existing Workflow using [JSON Patch](https://tools.ietf.org/html/rfc6902) syntax.
		     * @summary Patch Workflow
		     * @param {WorkflowsBetaApiPatchWorkflowRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof WorkflowsBetaApi
		     */
		    WorkflowsBetaApi.prototype.patchWorkflow = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.WorkflowsBetaApiFp)(this.configuration).patchWorkflow(requestParameters.id, requestParameters.jsonPatchOperationBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This endpoint allows a service outside of IdentityNow to initiate a workflow that uses the \"External Trigger\" step.  The external service will invoke this endpoint with the input data it wants to send to the workflow in the body.
		     * @summary Execute Workflow via External Trigger
		     * @param {WorkflowsBetaApiPostExternalExecuteWorkflowRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof WorkflowsBetaApi
		     */
		    WorkflowsBetaApi.prototype.postExternalExecuteWorkflow = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.WorkflowsBetaApiFp)(this.configuration).postExternalExecuteWorkflow(requestParameters.id, requestParameters.postExternalExecuteWorkflowRequestBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Create OAuth client ID, client secret, and callback URL for use in an external trigger.  External triggers will need this information to generate an access token to authenticate to the callback URL and submit a trigger payload that will initiate the workflow.
		     * @summary Generate External Trigger OAuth Client
		     * @param {WorkflowsBetaApiPostWorkflowExternalTriggerRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof WorkflowsBetaApi
		     */
		    WorkflowsBetaApi.prototype.postWorkflowExternalTrigger = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.WorkflowsBetaApiFp)(this.configuration).postWorkflowExternalTrigger(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Validate a workflow with an \"External Trigger\" can receive input.  The response includes the input that the workflow received, which can be used to validate that the input is intact when it reaches the workflow.
		     * @summary Test Workflow via External Trigger
		     * @param {WorkflowsBetaApiTestExternalExecuteWorkflowRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof WorkflowsBetaApi
		     */
		    WorkflowsBetaApi.prototype.testExternalExecuteWorkflow = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.WorkflowsBetaApiFp)(this.configuration).testExternalExecuteWorkflow(requestParameters.id, requestParameters.testExternalExecuteWorkflowRequestBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Test a workflow with the provided input data.  The input data should resemble the input that the trigger will send the workflow.  See the [event trigger documentation](https://developer.sailpoint.com/idn/docs/event-triggers/available) for an example input for the trigger that initiates this workflow. This endpoint will return an execution ID, which can be used to lookup more information about the execution using the `Get a Workflow Execution` endpoint. **This will cause a live run of the workflow, which could result in unintended modifications to your IDN tenant.**
		     * @summary Test Workflow By Id
		     * @param {WorkflowsBetaApiTestWorkflowRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof WorkflowsBetaApi
		     */
		    WorkflowsBetaApi.prototype.testWorkflow = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.WorkflowsBetaApiFp)(this.configuration).testWorkflow(requestParameters.id, requestParameters.testWorkflowRequestBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Perform a full update of a workflow.  The updated workflow object is returned in the response.
		     * @summary Update Workflow
		     * @param {WorkflowsBetaApiUpdateWorkflowRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof WorkflowsBetaApi
		     */
		    WorkflowsBetaApi.prototype.updateWorkflow = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.WorkflowsBetaApiFp)(this.configuration).updateWorkflow(requestParameters.id, requestParameters.workflowBodyBeta, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return WorkflowsBetaApi;
		}(base_1.BaseAPI));
		exports.WorkflowsBetaApi = WorkflowsBetaApi;
		
	} (api$1));
	return api$1;
}

var configuration$2 = {};

var hasRequiredConfiguration$2;

function requireConfiguration$2 () {
	if (hasRequiredConfiguration$2) return configuration$2;
	hasRequiredConfiguration$2 = 1;
	/* tslint:disable */
	/* eslint-disable */
	/**
	 * IdentityNow Beta API
	 * Use these APIs to interact with the IdentityNow platform to achieve repeatable, automated processes with greater scalability. These APIs are in beta and are subject to change. We encourage you to join the SailPoint Developer Community forum at https://developer.sailpoint.com/discuss to connect with other developers using our APIs.
	 *
	 * The version of the OpenAPI document: 3.1.0-beta
	 *
	 *
	 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
	 * https://openapi-generator.tech
	 * Do not edit the class manually.
	 */
	Object.defineProperty(configuration$2, "__esModule", { value: true });
	configuration$2.Configuration = void 0;
	var Configuration = /** @class */ (function () {
	    function Configuration(param) {
	        if (param === void 0) { param = {}; }
	        this.apiKey = param.apiKey;
	        this.username = param.username;
	        this.password = param.password;
	        this.accessToken = param.accessToken;
	        this.basePath = param.basePath;
	        this.baseOptions = param.baseOptions;
	        this.formDataCtor = param.formDataCtor;
	    }
	    /**
	     * Check if the given MIME is a JSON MIME.
	     * JSON MIME examples:
	     *   application/json
	     *   application/json; charset=UTF8
	     *   APPLICATION/JSON
	     *   application/vnd.company+json
	     * @param mime - MIME (Multipurpose Internet Mail Extensions)
	     * @return True if the given MIME is JSON, false otherwise.
	     */
	    Configuration.prototype.isJsonMime = function (mime) {
	        var jsonMime = new RegExp('^(application\/json|[^;/ \t]+\/[^;/ \t]+[+]json)[ \t]*(;.*)?$', 'i');
	        return mime !== null && (jsonMime.test(mime) || mime.toLowerCase() === 'application/json-patch+json');
	    };
	    return Configuration;
	}());
	configuration$2.Configuration = Configuration;
	
	return configuration$2;
}

var api = {};

var common$1 = {};

var base = {};

var hasRequiredBase;

function requireBase () {
	if (hasRequiredBase) return base;
	hasRequiredBase = 1;
	(function (exports) {
		/* tslint:disable */
		/* eslint-disable */
		/**
		 * IdentityNow V3 API
		 * Use these APIs to interact with the IdentityNow platform to achieve repeatable, automated processes with greater scalability. We encourage you to join the SailPoint Developer Community forum at https://developer.sailpoint.com/discuss to connect with other developers using our APIs.
		 *
		 * The version of the OpenAPI document: 3.0.0
		 *
		 *
		 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
		 * https://openapi-generator.tech
		 * Do not edit the class manually.
		 */
		var __extends = (commonjsGlobal && commonjsGlobal.__extends) || (function () {
		    var extendStatics = function (d, b) {
		        extendStatics = Object.setPrototypeOf ||
		            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
		            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
		        return extendStatics(d, b);
		    };
		    return function (d, b) {
		        if (typeof b !== "function" && b !== null)
		            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
		        extendStatics(d, b);
		        function __() { this.constructor = d; }
		        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
		    };
		})();
		var __importDefault = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
		    return (mod && mod.__esModule) ? mod : { "default": mod };
		};
		Object.defineProperty(exports, "__esModule", { value: true });
		exports.RequiredError = exports.BaseAPI = exports.COLLECTION_FORMATS = exports.BASE_PATH = void 0;
		// Some imports not used depending on template conditions
		// @ts-ignore
		var axios_1 = __importDefault(requireAxios());
		exports.BASE_PATH = "https://sailpoint.api.identitynow.com/v3".replace(/\/+$/, "");
		/**
		 *
		 * @export
		 */
		exports.COLLECTION_FORMATS = {
		    csv: ",",
		    ssv: " ",
		    tsv: "\t",
		    pipes: "|",
		};
		/**
		 *
		 * @export
		 * @class BaseAPI
		 */
		var BaseAPI = /** @class */ (function () {
		    function BaseAPI(configuration, basePath, axios) {
		        if (basePath === void 0) { basePath = exports.BASE_PATH; }
		        if (axios === void 0) { axios = axios_1.default; }
		        this.basePath = basePath;
		        this.axios = axios;
		        if (configuration) {
		            this.configuration = configuration;
		            this.basePath = configuration.basePath + "/v3" || this.basePath;
		        }
		    }
		    return BaseAPI;
		}());
		exports.BaseAPI = BaseAPI;
		/**
		 *
		 * @export
		 * @class RequiredError
		 * @extends {Error}
		 */
		var RequiredError = /** @class */ (function (_super) {
		    __extends(RequiredError, _super);
		    function RequiredError(field, msg) {
		        var _this = _super.call(this, msg) || this;
		        _this.field = field;
		        _this.name = "RequiredError";
		        return _this;
		    }
		    return RequiredError;
		}(Error));
		exports.RequiredError = RequiredError;
		
	} (base));
	return base;
}

var hasRequiredCommon$1;

function requireCommon$1 () {
	if (hasRequiredCommon$1) return common$1;
	hasRequiredCommon$1 = 1;
	/* tslint:disable */
	/* eslint-disable */
	/**
	 * IdentityNow V3 API
	 * Use these APIs to interact with the IdentityNow platform to achieve repeatable, automated processes with greater scalability. We encourage you to join the SailPoint Developer Community forum at https://developer.sailpoint.com/discuss to connect with other developers using our APIs.
	 *
	 * The version of the OpenAPI document: 3.0.0
	 *
	 *
	 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
	 * https://openapi-generator.tech
	 * Do not edit the class manually.
	 */
	var __assign = (commonjsGlobal && commonjsGlobal.__assign) || function () {
	    __assign = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign.apply(this, arguments);
	};
	var __awaiter = (commonjsGlobal && commonjsGlobal.__awaiter) || function (thisArg, _arguments, P, generator) {
	    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
	    return new (P || (P = Promise))(function (resolve, reject) {
	        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
	        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
	        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
	        step((generator = generator.apply(thisArg, _arguments || [])).next());
	    });
	};
	var __generator = (commonjsGlobal && commonjsGlobal.__generator) || function (thisArg, body) {
	    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
	    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
	    function verb(n) { return function (v) { return step([n, v]); }; }
	    function step(op) {
	        if (f) throw new TypeError("Generator is already executing.");
	        while (g && (g = 0, op[0] && (_ = 0)), _) try {
	            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
	            if (y = 0, t) op = [op[0] & 2, t.value];
	            switch (op[0]) {
	                case 0: case 1: t = op; break;
	                case 4: _.label++; return { value: op[1], done: false };
	                case 5: _.label++; y = op[1]; op = [0]; continue;
	                case 7: op = _.ops.pop(); _.trys.pop(); continue;
	                default:
	                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
	                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
	                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
	                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
	                    if (t[2]) _.ops.pop();
	                    _.trys.pop(); continue;
	            }
	            op = body.call(thisArg, _);
	        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
	        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
	    }
	};
	var __importDefault = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
	    return (mod && mod.__esModule) ? mod : { "default": mod };
	};
	Object.defineProperty(common$1, "__esModule", { value: true });
	common$1.createRequestFunction = common$1.toPathString = common$1.serializeDataIfNeeded = common$1.setSearchParams = common$1.setOAuthToObject = common$1.setBearerAuthToObject = common$1.setBasicAuthToObject = common$1.setApiKeyToObject = common$1.assertParamExists = common$1.DUMMY_BASE_URL = void 0;
	var base_1 = requireBase();
	var axios_retry_1 = __importDefault(requireAxiosRetry());
	/**
	 *
	 * @export
	 */
	common$1.DUMMY_BASE_URL = 'https://example.com';
	/**
	 *
	 * @throws {RequiredError}
	 * @export
	 */
	var assertParamExists = function (functionName, paramName, paramValue) {
	    if (paramValue === null || paramValue === undefined) {
	        throw new base_1.RequiredError(paramName, "Required parameter ".concat(paramName, " was null or undefined when calling ").concat(functionName, "."));
	    }
	};
	common$1.assertParamExists = assertParamExists;
	/**
	 *
	 * @export
	 */
	var setApiKeyToObject = function (object, keyParamName, configuration) {
	    return __awaiter(this, void 0, void 0, function () {
	        var localVarApiKeyValue, _a;
	        return __generator(this, function (_b) {
	            switch (_b.label) {
	                case 0:
	                    if (!(configuration && configuration.apiKey)) return [3 /*break*/, 5];
	                    if (!(typeof configuration.apiKey === 'function')) return [3 /*break*/, 2];
	                    return [4 /*yield*/, configuration.apiKey(keyParamName)];
	                case 1:
	                    _a = _b.sent();
	                    return [3 /*break*/, 4];
	                case 2: return [4 /*yield*/, configuration.apiKey];
	                case 3:
	                    _a = _b.sent();
	                    _b.label = 4;
	                case 4:
	                    localVarApiKeyValue = _a;
	                    object[keyParamName] = localVarApiKeyValue;
	                    _b.label = 5;
	                case 5: return [2 /*return*/];
	            }
	        });
	    });
	};
	common$1.setApiKeyToObject = setApiKeyToObject;
	/**
	 *
	 * @export
	 */
	var setBasicAuthToObject = function (object, configuration) {
	    if (configuration && (configuration.username || configuration.password)) {
	        object["auth"] = { username: configuration.username, password: configuration.password };
	    }
	};
	common$1.setBasicAuthToObject = setBasicAuthToObject;
	/**
	 *
	 * @export
	 */
	var setBearerAuthToObject = function (object, configuration) {
	    return __awaiter(this, void 0, void 0, function () {
	        var accessToken, _a;
	        return __generator(this, function (_b) {
	            switch (_b.label) {
	                case 0:
	                    if (!(configuration && configuration.accessToken)) return [3 /*break*/, 5];
	                    if (!(typeof configuration.accessToken === 'function')) return [3 /*break*/, 2];
	                    return [4 /*yield*/, configuration.accessToken()];
	                case 1:
	                    _a = _b.sent();
	                    return [3 /*break*/, 4];
	                case 2: return [4 /*yield*/, configuration.accessToken];
	                case 3:
	                    _a = _b.sent();
	                    _b.label = 4;
	                case 4:
	                    accessToken = _a;
	                    object["Authorization"] = "Bearer " + accessToken;
	                    _b.label = 5;
	                case 5: return [2 /*return*/];
	            }
	        });
	    });
	};
	common$1.setBearerAuthToObject = setBearerAuthToObject;
	/**
	 *
	 * @export
	 */
	var setOAuthToObject = function (object, name, scopes, configuration) {
	    return __awaiter(this, void 0, void 0, function () {
	        var localVarAccessTokenValue, _a;
	        return __generator(this, function (_b) {
	            switch (_b.label) {
	                case 0:
	                    if (!(configuration && configuration.accessToken)) return [3 /*break*/, 5];
	                    if (!(typeof configuration.accessToken === 'function')) return [3 /*break*/, 2];
	                    return [4 /*yield*/, configuration.accessToken(name, scopes)];
	                case 1:
	                    _a = _b.sent();
	                    return [3 /*break*/, 4];
	                case 2: return [4 /*yield*/, configuration.accessToken];
	                case 3:
	                    _a = _b.sent();
	                    _b.label = 4;
	                case 4:
	                    localVarAccessTokenValue = _a;
	                    object["Authorization"] = "Bearer " + localVarAccessTokenValue;
	                    _b.label = 5;
	                case 5: return [2 /*return*/];
	            }
	        });
	    });
	};
	common$1.setOAuthToObject = setOAuthToObject;
	/**
	 *
	 * @export
	 */
	var setSearchParams = function (url) {
	    var objects = [];
	    for (var _i = 1; _i < arguments.length; _i++) {
	        objects[_i - 1] = arguments[_i];
	    }
	    var searchParams = new URLSearchParams(url.search);
	    for (var _a = 0, objects_1 = objects; _a < objects_1.length; _a++) {
	        var object = objects_1[_a];
	        for (var key in object) {
	            if (Array.isArray(object[key])) {
	                searchParams.delete(key);
	                for (var _b = 0, _c = object[key]; _b < _c.length; _b++) {
	                    var item = _c[_b];
	                    searchParams.append(key, item);
	                }
	            }
	            else {
	                searchParams.set(key, object[key]);
	            }
	        }
	    }
	    url.search = searchParams.toString();
	};
	common$1.setSearchParams = setSearchParams;
	/**
	 *
	 * @export
	 */
	var serializeDataIfNeeded = function (value, requestOptions, configuration) {
	    var nonString = typeof value !== 'string';
	    var needsSerialization = nonString && configuration && configuration.isJsonMime
	        ? configuration.isJsonMime(requestOptions.headers['Content-Type'])
	        : nonString;
	    return needsSerialization
	        ? JSON.stringify(value !== undefined ? value : {})
	        : (value || "");
	};
	common$1.serializeDataIfNeeded = serializeDataIfNeeded;
	/**
	 *
	 * @export
	 */
	var toPathString = function (url) {
	    return url.pathname + url.search + url.hash;
	};
	common$1.toPathString = toPathString;
	/**
	 *
	 * @export
	 */
	var createRequestFunction = function (axiosArgs, globalAxios, BASE_PATH, configuration) {
	    return function (axios, basePath) {
	        if (axios === void 0) { axios = globalAxios; }
	        if (basePath === void 0) { basePath = BASE_PATH; }
	        (0, axios_retry_1.default)(globalAxios, configuration.retriesConfig);
	        axiosArgs.axiosOptions.headers['X-SailPoint-SDK'] = 'typescript-1.3.1';
	        axiosArgs.axiosOptions.headers['User-Agent'] = 'OpenAPI-Generator/1.3.1/ts';
	        var axiosRequestArgs = __assign(__assign({}, axiosArgs.axiosOptions), { url: ((configuration === null || configuration === void 0 ? void 0 : configuration.basePath) + "/v3" || basePath) + axiosArgs.url });
	        return axios.request(axiosRequestArgs);
	    };
	};
	common$1.createRequestFunction = createRequestFunction;
	
	return common$1;
}

var hasRequiredApi;

function requireApi () {
	if (hasRequiredApi) return api;
	hasRequiredApi = 1;
	(function (exports) {
		/* tslint:disable */
		/* eslint-disable */
		/**
		 * IdentityNow V3 API
		 * Use these APIs to interact with the IdentityNow platform to achieve repeatable, automated processes with greater scalability. We encourage you to join the SailPoint Developer Community forum at https://developer.sailpoint.com/discuss to connect with other developers using our APIs.
		 *
		 * The version of the OpenAPI document: 3.0.0
		 *
		 *
		 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
		 * https://openapi-generator.tech
		 * Do not edit the class manually.
		 */
		var __extends = (commonjsGlobal && commonjsGlobal.__extends) || (function () {
		    var extendStatics = function (d, b) {
		        extendStatics = Object.setPrototypeOf ||
		            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
		            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
		        return extendStatics(d, b);
		    };
		    return function (d, b) {
		        if (typeof b !== "function" && b !== null)
		            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
		        extendStatics(d, b);
		        function __() { this.constructor = d; }
		        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
		    };
		})();
		var __assign = (commonjsGlobal && commonjsGlobal.__assign) || function () {
		    __assign = Object.assign || function(t) {
		        for (var s, i = 1, n = arguments.length; i < n; i++) {
		            s = arguments[i];
		            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
		                t[p] = s[p];
		        }
		        return t;
		    };
		    return __assign.apply(this, arguments);
		};
		var __awaiter = (commonjsGlobal && commonjsGlobal.__awaiter) || function (thisArg, _arguments, P, generator) {
		    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
		    return new (P || (P = Promise))(function (resolve, reject) {
		        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
		        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
		        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
		        step((generator = generator.apply(thisArg, _arguments || [])).next());
		    });
		};
		var __generator = (commonjsGlobal && commonjsGlobal.__generator) || function (thisArg, body) {
		    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
		    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
		    function verb(n) { return function (v) { return step([n, v]); }; }
		    function step(op) {
		        if (f) throw new TypeError("Generator is already executing.");
		        while (g && (g = 0, op[0] && (_ = 0)), _) try {
		            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
		            if (y = 0, t) op = [op[0] & 2, t.value];
		            switch (op[0]) {
		                case 0: case 1: t = op; break;
		                case 4: _.label++; return { value: op[1], done: false };
		                case 5: _.label++; y = op[1]; op = [0]; continue;
		                case 7: op = _.ops.pop(); _.trys.pop(); continue;
		                default:
		                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
		                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
		                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
		                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
		                    if (t[2]) _.ops.pop();
		                    _.trys.pop(); continue;
		            }
		            op = body.call(thisArg, _);
		        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
		        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
		    }
		};
		var __importDefault = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
		    return (mod && mod.__esModule) ? mod : { "default": mod };
		};
		Object.defineProperty(exports, "__esModule", { value: true });
		exports.CampaignReferenceCampaignTypeEnum = exports.CampaignReferenceTypeEnum = exports.CampaignFilterDetailsModeEnum = exports.CampaignCompleteOptionsAutoCompleteActionEnum = exports.CampaignAllOfSourcesWithOrphanEntitlementsTypeEnum = exports.CampaignAllOfSearchCampaignInfoReviewerTypeEnum = exports.CampaignAllOfSearchCampaignInfoTypeEnum = exports.CampaignAllOfRoleCompositionCampaignInfoRemediatorRefTypeEnum = exports.CampaignAllOfFilterTypeEnum = exports.CampaignAllOfMandatoryCommentRequirementEnum = exports.CampaignAllOfCorrelatedStatusEnum = exports.CampaignAlertLevelEnum = exports.CampaignMandatoryCommentRequirementEnum = exports.CampaignCorrelatedStatusEnum = exports.CampaignStatusEnum = exports.CampaignTypeEnum = exports.BulkTaggedObjectOperationEnum = exports.BucketType = exports.BeforeProvisioningRuleDtoTypeEnum = exports.BaseAccessAllOfOwnerTypeEnum = exports.AuthUserCapabilitiesEnum = exports.AttributeDefinitionType = exports.AttributeDefinitionSchemaTypeEnum = exports.ApprovalStatusDtoOriginalOwnerTypeEnum = exports.ApprovalStatusDtoCurrentOwnerTypeEnum = exports.ApprovalStatus = exports.ApprovalSchemeForRoleApproverTypeEnum = exports.ApprovalScheme = exports.AggregationType = exports.AdminReviewReassignReassignToTypeEnum = exports.ActivityInsightsUsageDaysStateEnum = exports.AccountActivityItemOperation = exports.AccountActionActionEnum = exports.AccessType = exports.AccessRequestType = exports.AccessRequestPhasesResultEnum = exports.AccessRequestPhasesStateEnum = exports.AccessRequestItemTypeEnum = exports.AccessProfileUsageUsedByInnerTypeEnum = exports.AccessProfileSourceRefTypeEnum = exports.AccessProfileRefTypeEnum = exports.AccessProfileDocumentAllOfTypeEnum = exports.AccessProfileDocumentTypeEnum = exports.AccessProfileApprovalSchemeApproverTypeEnum = exports.AccessItemReviewedByTypeEnum = exports.AccessItemRequesterTypeEnum = exports.AccessItemRequestedForTypeEnum = exports.AccessCriteriaCriteriaListInnerTypeEnum = exports.AccessConstraintOperatorEnum = exports.AccessConstraintTypeEnum = void 0;
		exports.OrphanUncorrelatedReportArgumentsSelectedFormatsEnum = exports.Operation = exports.NonEmployeeSchemaAttributeType = exports.NonEmployeeIdentityDtoType = exports.NonEmployeeBulkUploadStatusStatusEnum = exports.NonEmployeeBulkUploadJobStatusEnum = exports.NamedConstructs = exports.MetricType = exports.ManualWorkItemState = exports.ManualWorkItemDetailsOriginalOwnerTypeEnum = exports.ManualWorkItemDetailsCurrentOwnerTypeEnum = exports.LocaleOrigin = exports.LifecyclestateDeletedTypeEnum = exports.JsonPatchOperationOpEnum = exports.Index = exports.ImportObjectTypeEnum = exports.IdentityWithNewAccessAccessRefsInnerTypeEnum = exports.IdentityWithNewAccess1AccessRefsInnerTypeEnum = exports.IdentityProfileExportedObjectSelfTypeEnum = exports.IdentityProfileAllOfOwnerTypeEnum = exports.IdentityProfileAllOfAuthoritativeSourceTypeEnum = exports.GrantType = exports.FilterType = exports.ExpressionChildrenInnerOperatorEnum = exports.ExpressionOperatorEnum = exports.ExecutionStatus = exports.ExceptionCriteriaCriteriaListInnerTypeEnum = exports.EntitlementRef1TypeEnum = exports.EntitlementRefTypeEnum = exports.DtoType = exports.DocumentType = exports.DeleteSource202ResponseTypeEnum = exports.DateCompareOperatorEnum = exports.CriteriaType = exports.ConnectorDetailStatusEnum = exports.CompletionStatus = exports.CompletedApprovalState = exports.CommentDtoAuthorTypeEnum = exports.ClientType = exports.CertificationTaskStatusEnum = exports.CertificationTaskTargetTypeEnum = exports.CertificationTaskTypeEnum = exports.CertificationReferenceTypeEnum = exports.CertificationPhase = exports.CertificationDecision = exports.CampaignTemplateOwnerRefTypeEnum = exports.CampaignReportStatusEnum = exports.CampaignReportTypeEnum = exports.CampaignReferenceMandatoryCommentRequirementEnum = exports.CampaignReferenceCorrelatedStatusEnum = void 0;
		exports.SlimCampaignCorrelatedStatusEnum = exports.SlimCampaignStatusEnum = exports.SlimCampaignTypeEnum = exports.ServiceDeskSourceTypeEnum = exports.SelectorType = exports.SearchScheduleRecipientsInnerTypeEnum = exports.SearchFilterType = exports.ScheduledSearchAllOfOwnerTypeEnum = exports.ScheduleType = exports.ScheduleMonthsTypeEnum = exports.ScheduleHoursTypeEnum = exports.ScheduleDaysTypeEnum = exports.ScheduleTypeEnum = exports.RoleMembershipSelectorType = exports.RoleCriteriaOperation = exports.RoleCriteriaKeyType = exports.RoleAssignmentSourceType = exports.ReviewerTypeEnum = exports.RequestedItemStatusSodViolationContextStateEnum = exports.RequestedItemStatusRequestState = exports.RequestedItemStatusPreApprovalTriggerDetailsDecisionEnum = exports.RequestedItemStatusTypeEnum = exports.RequestableObjectType = exports.RequestableObjectRequestStatus = exports.RequestableObjectReferenceTypeEnum = exports.ReportType = exports.ReportResultsAvailableFormatsEnum = exports.ReportResultsStatusEnum = exports.ReportResultsReportTypeEnum = exports.ReportResultReferenceAllOfStatusEnum = exports.ReportResultReferenceStatusEnum = exports.ReportResultReferenceTypeEnum = exports.ReportDetailsReportTypeEnum = exports.ReassignmentType = exports.ReassignmentReferenceTypeEnum = exports.ReassignReferenceTypeEnum = exports.QueryType = exports.PublicIdentityIdentityStateEnum = exports.ProvisioningState = exports.ProvisioningCriteriaOperation = exports.ProvisioningConfigManagedResourceRefsInnerTypeEnum = exports.PreApprovalTriggerDetailsDecisionEnum = exports.PendingApprovalOwnerTypeEnum = exports.PendingApprovalAction = exports.PatOwnerTypeEnum = exports.PasswordStatusStateEnum = exports.PasswordChangeResponseStateEnum = exports.OwnerReferenceSegmentsTypeEnum = exports.OwnerReferenceTypeEnum = exports.OwnerDtoTypeEnum = void 0;
		exports.AccessRequestsApi = exports.AccessRequestsApiFactory = exports.AccessRequestsApiFp = exports.AccessRequestsApiAxiosParamCreator = exports.AccessRequestApprovalsApi = exports.AccessRequestApprovalsApiFactory = exports.AccessRequestApprovalsApiFp = exports.AccessRequestApprovalsApiAxiosParamCreator = exports.AccessProfilesApi = exports.AccessProfilesApiFactory = exports.AccessProfilesApiFp = exports.AccessProfilesApiAxiosParamCreator = exports.WorkItemTypeManualWorkItems = exports.WorkItemStateManualWorkItems = exports.WorkItemState = exports.ViolationOwnerAssignmentConfigOwnerRefTypeEnum = exports.ViolationOwnerAssignmentConfigAssignmentRuleEnum = exports.ViolationContextPolicyTypeEnum = exports.V3CreateConnectorDtoStatusEnum = exports.V3ConnectorDtoStatusEnum = exports.UsageType = exports.UpdateDetailStatusEnum = exports.TransformReadTypeEnum = exports.TransformTypeEnum = exports.TaskResultSimplifiedCompletionStatusEnum = exports.TaskResultDtoTypeEnum = exports.TaskResultDetailsMessagesInnerTypeEnum = exports.TaskResultDetailsCompletionStatusEnum = exports.TaskResultDetailsReportTypeEnum = exports.TaskResultDetailsTypeEnum = exports.TaggedObjectDtoTypeEnum = exports.SourceUsageStatusStatusEnum = exports.SourceSchemasInnerTypeEnum = exports.SourcePasswordPoliciesInnerTypeEnum = exports.SourceOwnerTypeEnum = exports.SourceManagerCorrelationRuleTypeEnum = exports.SourceManagementWorkgroupTypeEnum = exports.SourceHealthDtoStatusEnum = exports.SourceFeature = exports.SourceClusterDtoTypeEnum = exports.SourceClusterTypeEnum = exports.SourceBeforeProvisioningRuleTypeEnum = exports.SourceAccountCorrelationRuleTypeEnum = exports.SourceAccountCorrelationConfigTypeEnum = exports.SodViolationContextCheckCompletedStateEnum = exports.SodReportResultDtoTypeEnum = exports.SodRecipientTypeEnum = exports.SodPolicyDtoTypeEnum = exports.SodPolicyTypeEnum = exports.SodPolicyStateEnum = void 0;
		exports.LifecycleStatesApiFp = exports.LifecycleStatesApiAxiosParamCreator = exports.IdentityProfilesApi = exports.IdentityProfilesApiFactory = exports.IdentityProfilesApiFp = exports.IdentityProfilesApiAxiosParamCreator = exports.GlobalTenantSecuritySettingsApi = exports.GlobalTenantSecuritySettingsApiFactory = exports.GlobalTenantSecuritySettingsApiFp = exports.GlobalTenantSecuritySettingsApiAxiosParamCreator = exports.ConnectorsApi = exports.ConnectorsApiFactory = exports.ConnectorsApiFp = exports.ConnectorsApiAxiosParamCreator = exports.CertificationsApi = exports.CertificationsApiFactory = exports.CertificationsApiFp = exports.CertificationsApiAxiosParamCreator = exports.CertificationSummariesApi = exports.CertificationSummariesApiFactory = exports.CertificationSummariesApiFp = exports.CertificationSummariesApiAxiosParamCreator = exports.CertificationCampaignsApi = exports.CertificationCampaignsApiFactory = exports.CertificationCampaignsApiFp = exports.CertificationCampaignsApiAxiosParamCreator = exports.CertificationCampaignFiltersApi = exports.CertificationCampaignFiltersApiFactory = exports.CertificationCampaignFiltersApiFp = exports.CertificationCampaignFiltersApiAxiosParamCreator = exports.BrandingApi = exports.BrandingApiFactory = exports.BrandingApiFp = exports.BrandingApiAxiosParamCreator = exports.AuthUserApi = exports.AuthUserApiFactory = exports.AuthUserApiFp = exports.AuthUserApiAxiosParamCreator = exports.AccountsApi = exports.AccountsApiFactory = exports.AccountsApiFp = exports.AccountsApiAxiosParamCreator = exports.AccountUsagesApi = exports.AccountUsagesApiFactory = exports.AccountUsagesApiFp = exports.AccountUsagesApiAxiosParamCreator = exports.AccountActivitiesApi = exports.AccountActivitiesApiFactory = exports.AccountActivitiesApiFp = exports.AccountActivitiesApiAxiosParamCreator = void 0;
		exports.RolesApi = exports.RolesApiFactory = exports.RolesApiFp = exports.RolesApiAxiosParamCreator = exports.RequestableObjectsApi = exports.RequestableObjectsApiFactory = exports.RequestableObjectsApiFp = exports.RequestableObjectsApiAxiosParamCreator = exports.ReportsDataExtractionApi = exports.ReportsDataExtractionApiFactory = exports.ReportsDataExtractionApiFp = exports.ReportsDataExtractionApiAxiosParamCreator = exports.PublicIdentitiesConfigApi = exports.PublicIdentitiesConfigApiFactory = exports.PublicIdentitiesConfigApiFp = exports.PublicIdentitiesConfigApiAxiosParamCreator = exports.PublicIdentitiesApi = exports.PublicIdentitiesApiFactory = exports.PublicIdentitiesApiFp = exports.PublicIdentitiesApiAxiosParamCreator = exports.PersonalAccessTokensApi = exports.PersonalAccessTokensApiFactory = exports.PersonalAccessTokensApiFp = exports.PersonalAccessTokensApiAxiosParamCreator = exports.PasswordSyncGroupsApi = exports.PasswordSyncGroupsApiFactory = exports.PasswordSyncGroupsApiFp = exports.PasswordSyncGroupsApiAxiosParamCreator = exports.PasswordManagementApi = exports.PasswordManagementApiFactory = exports.PasswordManagementApiFp = exports.PasswordManagementApiAxiosParamCreator = exports.PasswordDictionaryApi = exports.PasswordDictionaryApiFactory = exports.PasswordDictionaryApiFp = exports.PasswordDictionaryApiAxiosParamCreator = exports.PasswordConfigurationApi = exports.PasswordConfigurationApiFactory = exports.PasswordConfigurationApiFp = exports.PasswordConfigurationApiAxiosParamCreator = exports.OAuthClientsApi = exports.OAuthClientsApiFactory = exports.OAuthClientsApiFp = exports.OAuthClientsApiAxiosParamCreator = exports.NonEmployeeLifecycleManagementApi = exports.NonEmployeeLifecycleManagementApiFactory = exports.NonEmployeeLifecycleManagementApiFp = exports.NonEmployeeLifecycleManagementApiAxiosParamCreator = exports.LifecycleStatesApi = exports.LifecycleStatesApiFactory = void 0;
		exports.WorkItemsApi = exports.WorkItemsApiFactory = exports.WorkItemsApiFp = exports.WorkItemsApiAxiosParamCreator = exports.TransformsApi = exports.TransformsApiFactory = exports.TransformsApiFp = exports.TransformsApiAxiosParamCreator = exports.TaggedObjectsApi = exports.TaggedObjectsApiFactory = exports.TaggedObjectsApiFp = exports.TaggedObjectsApiAxiosParamCreator = exports.SourcesApi = exports.SourcesApiFactory = exports.SourcesApiFp = exports.SourcesApiAxiosParamCreator = exports.SourceUsagesApi = exports.SourceUsagesApiFactory = exports.SourceUsagesApiFp = exports.SourceUsagesApiAxiosParamCreator = exports.ServiceDeskIntegrationApi = exports.ServiceDeskIntegrationApiFactory = exports.ServiceDeskIntegrationApiFp = exports.ServiceDeskIntegrationApiAxiosParamCreator = exports.SegmentsApi = exports.SegmentsApiFactory = exports.SegmentsApiFp = exports.SegmentsApiAxiosParamCreator = exports.SearchApi = exports.SearchApiFactory = exports.SearchApiFp = exports.SearchApiAxiosParamCreator = exports.ScheduledSearchApi = exports.ScheduledSearchApiFactory = exports.ScheduledSearchApiFp = exports.ScheduledSearchApiAxiosParamCreator = exports.SavedSearchApi = exports.SavedSearchApiFactory = exports.SavedSearchApiFp = exports.SavedSearchApiAxiosParamCreator = exports.SODViolationsApi = exports.SODViolationsApiFactory = exports.SODViolationsApiFp = exports.SODViolationsApiAxiosParamCreator = exports.SODPolicyApi = exports.SODPolicyApiFactory = exports.SODPolicyApiFp = exports.SODPolicyApiAxiosParamCreator = void 0;
		var axios_1 = __importDefault(requireAxios());
		// Some imports not used depending on template conditions
		// @ts-ignore
		var common_1 = requireCommon$1();
		// @ts-ignore
		var base_1 = requireBase();
		exports.AccessConstraintTypeEnum = {
		    Entitlement: 'ENTITLEMENT',
		    AccessProfile: 'ACCESS_PROFILE',
		    Role: 'ROLE'
		};
		exports.AccessConstraintOperatorEnum = {
		    All: 'ALL',
		    Selected: 'SELECTED'
		};
		exports.AccessCriteriaCriteriaListInnerTypeEnum = {
		    Entitlement: 'ENTITLEMENT'
		};
		exports.AccessItemRequestedForTypeEnum = {
		    Identity: 'IDENTITY'
		};
		exports.AccessItemRequesterTypeEnum = {
		    Identity: 'IDENTITY'
		};
		exports.AccessItemReviewedByTypeEnum = {
		    Identity: 'IDENTITY'
		};
		exports.AccessProfileApprovalSchemeApproverTypeEnum = {
		    AppOwner: 'APP_OWNER',
		    Owner: 'OWNER',
		    SourceOwner: 'SOURCE_OWNER',
		    Manager: 'MANAGER',
		    GovernanceGroup: 'GOVERNANCE_GROUP'
		};
		exports.AccessProfileDocumentTypeEnum = {
		    Accessprofile: 'accessprofile',
		    Accountactivity: 'accountactivity',
		    Account: 'account',
		    Aggregation: 'aggregation',
		    Entitlement: 'entitlement',
		    Event: 'event',
		    Identity: 'identity',
		    Role: 'role'
		};
		exports.AccessProfileDocumentAllOfTypeEnum = {
		    Accessprofile: 'accessprofile',
		    Accountactivity: 'accountactivity',
		    Account: 'account',
		    Aggregation: 'aggregation',
		    Entitlement: 'entitlement',
		    Event: 'event',
		    Identity: 'identity',
		    Role: 'role'
		};
		exports.AccessProfileRefTypeEnum = {
		    AccessProfile: 'ACCESS_PROFILE'
		};
		exports.AccessProfileSourceRefTypeEnum = {
		    Source: 'SOURCE'
		};
		exports.AccessProfileUsageUsedByInnerTypeEnum = {
		    Role: 'ROLE'
		};
		exports.AccessRequestItemTypeEnum = {
		    AccessProfile: 'ACCESS_PROFILE',
		    Role: 'ROLE',
		    Entitlement: 'ENTITLEMENT'
		};
		exports.AccessRequestPhasesStateEnum = {
		    Pending: 'PENDING',
		    Executing: 'EXECUTING',
		    Completed: 'COMPLETED',
		    Cancelled: 'CANCELLED',
		    NotExecuted: 'NOT_EXECUTED'
		};
		exports.AccessRequestPhasesResultEnum = {
		    Successful: 'SUCCESSFUL',
		    Failed: 'FAILED',
		    Null: 'null'
		};
		/**
		 * Access request type. Defaults to GRANT_ACCESS. REVOKE_ACCESS type can only have a single Identity ID in the requestedFor field.
		 * @export
		 * @enum {string}
		 */
		exports.AccessRequestType = {
		    GrantAccess: 'GRANT_ACCESS',
		    RevokeAccess: 'REVOKE_ACCESS',
		    Null: 'null'
		};
		/**
		 * Access type of API Client indicating online or offline use
		 * @export
		 * @enum {string}
		 */
		exports.AccessType = {
		    Online: 'ONLINE',
		    Offline: 'OFFLINE'
		};
		exports.AccountActionActionEnum = {
		    Enable: 'ENABLE',
		    Disable: 'DISABLE'
		};
		/**
		 * Represents an operation in an account activity item
		 * @export
		 * @enum {string}
		 */
		exports.AccountActivityItemOperation = {
		    Add: 'ADD',
		    Create: 'CREATE',
		    Modify: 'MODIFY',
		    Delete: 'DELETE',
		    Disable: 'DISABLE',
		    Enable: 'ENABLE',
		    Unlock: 'UNLOCK',
		    Lock: 'LOCK',
		    Remove: 'REMOVE',
		    Set: 'SET',
		    Null: 'null'
		};
		exports.ActivityInsightsUsageDaysStateEnum = {
		    Complete: 'COMPLETE',
		    Unknown: 'UNKNOWN'
		};
		exports.AdminReviewReassignReassignToTypeEnum = {
		    Identity: 'IDENTITY'
		};
		/**
		 * Enum representing the currently available query languages for aggregations, which are used to perform calculations or groupings on search results.  Additional values may be added in the future without notice.
		 * @export
		 * @enum {string}
		 */
		exports.AggregationType = {
		    Dsl: 'DSL',
		    Sailpoint: 'SAILPOINT'
		};
		/**
		 * Describes the individual or group that is responsible for an approval step.
		 * @export
		 * @enum {string}
		 */
		exports.ApprovalScheme = {
		    AppOwner: 'APP_OWNER',
		    SourceOwner: 'SOURCE_OWNER',
		    Manager: 'MANAGER',
		    RoleOwner: 'ROLE_OWNER',
		    AccessProfileOwner: 'ACCESS_PROFILE_OWNER',
		    EntitlementOwner: 'ENTITLEMENT_OWNER',
		    GovernanceGroup: 'GOVERNANCE_GROUP'
		};
		exports.ApprovalSchemeForRoleApproverTypeEnum = {
		    Owner: 'OWNER',
		    Manager: 'MANAGER',
		    GovernanceGroup: 'GOVERNANCE_GROUP'
		};
		/**
		 * Enum representing the non-employee request approval status
		 * @export
		 * @enum {string}
		 */
		exports.ApprovalStatus = {
		    Approved: 'APPROVED',
		    Rejected: 'REJECTED',
		    Pending: 'PENDING',
		    NotReady: 'NOT_READY',
		    Cancelled: 'CANCELLED'
		};
		exports.ApprovalStatusDtoCurrentOwnerTypeEnum = {
		    Identity: 'IDENTITY'
		};
		exports.ApprovalStatusDtoOriginalOwnerTypeEnum = {
		    GovernanceGroup: 'GOVERNANCE_GROUP',
		    Identity: 'IDENTITY'
		};
		exports.AttributeDefinitionSchemaTypeEnum = {
		    ConnectorSchema: 'CONNECTOR_SCHEMA'
		};
		/**
		 * The underlying type of the value which an AttributeDefinition represents.
		 * @export
		 * @enum {string}
		 */
		exports.AttributeDefinitionType = {
		    String: 'STRING',
		    Long: 'LONG',
		    Int: 'INT',
		    Boolean: 'BOOLEAN'
		};
		exports.AuthUserCapabilitiesEnum = {
		    CertAdmin: 'CERT_ADMIN',
		    CloudGovAdmin: 'CLOUD_GOV_ADMIN',
		    CloudGovUser: 'CLOUD_GOV_USER',
		    Helpdesk: 'HELPDESK',
		    OrgAdmin: 'ORG_ADMIN',
		    ReportAdmin: 'REPORT_ADMIN',
		    RoleAdmin: 'ROLE_ADMIN',
		    RoleSubadmin: 'ROLE_SUBADMIN',
		    SaasManagementAdmin: 'SAAS_MANAGEMENT_ADMIN',
		    SaasManagementReader: 'SAAS_MANAGEMENT_READER',
		    SourceAdmin: 'SOURCE_ADMIN',
		    SourceSubadmin: 'SOURCE_SUBADMIN',
		    DasuiAdministrator: 'das:ui-administrator',
		    DasuiComplianceManager: 'das:ui-compliance_manager',
		    DasuiAuditor: 'das:ui-auditor',
		    DasuiDataScope: 'das:ui-data-scope',
		    SpaicDashboardRead: 'sp:aic-dashboard-read',
		    SpaicDashboardWrite: 'sp:aic-dashboard-write'
		};
		exports.BaseAccessAllOfOwnerTypeEnum = {
		    Identity: 'IDENTITY'
		};
		exports.BeforeProvisioningRuleDtoTypeEnum = {
		    Rule: 'RULE'
		};
		/**
		 * Enum representing the currently supported bucket aggregation types. Additional values may be added in the future without notice.
		 * @export
		 * @enum {string}
		 */
		exports.BucketType = {
		    Terms: 'TERMS'
		};
		exports.BulkTaggedObjectOperationEnum = {
		    Append: 'APPEND',
		    Merge: 'MERGE'
		};
		exports.CampaignTypeEnum = {
		    Manager: 'MANAGER',
		    SourceOwner: 'SOURCE_OWNER',
		    Search: 'SEARCH',
		    RoleComposition: 'ROLE_COMPOSITION'
		};
		exports.CampaignStatusEnum = {
		    Pending: 'PENDING',
		    Staged: 'STAGED',
		    Canceling: 'CANCELING',
		    Activating: 'ACTIVATING',
		    Active: 'ACTIVE',
		    Completing: 'COMPLETING',
		    Completed: 'COMPLETED',
		    Error: 'ERROR',
		    Archived: 'ARCHIVED'
		};
		exports.CampaignCorrelatedStatusEnum = {
		    Correlated: 'CORRELATED',
		    Uncorrelated: 'UNCORRELATED'
		};
		exports.CampaignMandatoryCommentRequirementEnum = {
		    AllDecisions: 'ALL_DECISIONS',
		    RevokeOnlyDecisions: 'REVOKE_ONLY_DECISIONS',
		    NoDecisions: 'NO_DECISIONS'
		};
		exports.CampaignAlertLevelEnum = {
		    Error: 'ERROR',
		    Warn: 'WARN',
		    Info: 'INFO'
		};
		exports.CampaignAllOfCorrelatedStatusEnum = {
		    Correlated: 'CORRELATED',
		    Uncorrelated: 'UNCORRELATED'
		};
		exports.CampaignAllOfMandatoryCommentRequirementEnum = {
		    AllDecisions: 'ALL_DECISIONS',
		    RevokeOnlyDecisions: 'REVOKE_ONLY_DECISIONS',
		    NoDecisions: 'NO_DECISIONS'
		};
		exports.CampaignAllOfFilterTypeEnum = {
		    CampaignFilter: 'CAMPAIGN_FILTER',
		    Rule: 'RULE'
		};
		exports.CampaignAllOfRoleCompositionCampaignInfoRemediatorRefTypeEnum = {
		    Identity: 'IDENTITY'
		};
		exports.CampaignAllOfSearchCampaignInfoTypeEnum = {
		    Identity: 'IDENTITY',
		    Access: 'ACCESS'
		};
		exports.CampaignAllOfSearchCampaignInfoReviewerTypeEnum = {
		    GovernanceGroup: 'GOVERNANCE_GROUP',
		    Identity: 'IDENTITY'
		};
		exports.CampaignAllOfSourcesWithOrphanEntitlementsTypeEnum = {
		    Source: 'SOURCE'
		};
		exports.CampaignCompleteOptionsAutoCompleteActionEnum = {
		    Approve: 'APPROVE',
		    Revoke: 'REVOKE'
		};
		exports.CampaignFilterDetailsModeEnum = {
		    Inclusion: 'INCLUSION',
		    Exclusion: 'EXCLUSION'
		};
		exports.CampaignReferenceTypeEnum = {
		    Campaign: 'CAMPAIGN'
		};
		exports.CampaignReferenceCampaignTypeEnum = {
		    Manager: 'MANAGER',
		    SourceOwner: 'SOURCE_OWNER',
		    Search: 'SEARCH'
		};
		exports.CampaignReferenceCorrelatedStatusEnum = {
		    Correlated: 'CORRELATED',
		    Uncorrelated: 'UNCORRELATED'
		};
		exports.CampaignReferenceMandatoryCommentRequirementEnum = {
		    AllDecisions: 'ALL_DECISIONS',
		    RevokeOnlyDecisions: 'REVOKE_ONLY_DECISIONS',
		    NoDecisions: 'NO_DECISIONS'
		};
		exports.CampaignReportTypeEnum = {
		    ReportResult: 'REPORT_RESULT'
		};
		exports.CampaignReportStatusEnum = {
		    Success: 'SUCCESS',
		    Warning: 'WARNING',
		    Error: 'ERROR',
		    Terminated: 'TERMINATED',
		    TempError: 'TEMP_ERROR',
		    Pending: 'PENDING'
		};
		exports.CampaignTemplateOwnerRefTypeEnum = {
		    Identity: 'IDENTITY'
		};
		/**
		 * The decision to approve or revoke the review item
		 * @export
		 * @enum {string}
		 */
		exports.CertificationDecision = {
		    Approve: 'APPROVE',
		    Revoke: 'REVOKE'
		};
		/**
		 * The current phase of the campaign. * `STAGED`: The campaign is waiting to be activated. * `ACTIVE`: The campaign is active. * `SIGNED`: The reviewer has signed off on the campaign, and it is considered complete.
		 * @export
		 * @enum {string}
		 */
		exports.CertificationPhase = {
		    Staged: 'STAGED',
		    Active: 'ACTIVE',
		    Signed: 'SIGNED'
		};
		exports.CertificationReferenceTypeEnum = {
		    Certification: 'CERTIFICATION'
		};
		exports.CertificationTaskTypeEnum = {
		    Reassign: 'REASSIGN',
		    AdminReassign: 'ADMIN_REASSIGN',
		    CompleteCertification: 'COMPLETE_CERTIFICATION',
		    FinishCertification: 'FINISH_CERTIFICATION',
		    CompleteCampaign: 'COMPLETE_CAMPAIGN',
		    ActivateCampaign: 'ACTIVATE_CAMPAIGN',
		    CampaignCreate: 'CAMPAIGN_CREATE',
		    CampaignDelete: 'CAMPAIGN_DELETE'
		};
		exports.CertificationTaskTargetTypeEnum = {
		    Certification: 'CERTIFICATION',
		    Campaign: 'CAMPAIGN'
		};
		exports.CertificationTaskStatusEnum = {
		    Queued: 'QUEUED',
		    InProgress: 'IN_PROGRESS',
		    Success: 'SUCCESS',
		    Error: 'ERROR'
		};
		/**
		 * Type of an API Client indicating public or confidentials use
		 * @export
		 * @enum {string}
		 */
		exports.ClientType = {
		    Confidential: 'CONFIDENTIAL',
		    Public: 'PUBLIC'
		};
		exports.CommentDtoAuthorTypeEnum = {
		    Identity: 'IDENTITY'
		};
		/**
		 * Enum represents completed approval object\'s state.
		 * @export
		 * @enum {string}
		 */
		exports.CompletedApprovalState = {
		    Approved: 'APPROVED',
		    Rejected: 'REJECTED'
		};
		/**
		 * The status after completion.
		 * @export
		 * @enum {string}
		 */
		exports.CompletionStatus = {
		    Success: 'SUCCESS',
		    Failure: 'FAILURE',
		    Incomplete: 'INCOMPLETE',
		    Pending: 'PENDING',
		    Null: 'null'
		};
		exports.ConnectorDetailStatusEnum = {
		    Deprecated: 'DEPRECATED',
		    Development: 'DEVELOPMENT',
		    Demo: 'DEMO',
		    Released: 'RELEASED'
		};
		/**
		 * Type of the criteria in the filter. The `COMPOSITE` filter can contain multiple filters in an AND/OR relationship.
		 * @export
		 * @enum {string}
		 */
		exports.CriteriaType = {
		    Composite: 'COMPOSITE',
		    Role: 'ROLE',
		    Identity: 'IDENTITY',
		    IdentityAttribute: 'IDENTITY_ATTRIBUTE',
		    Entitlement: 'ENTITLEMENT',
		    AccessProfile: 'ACCESS_PROFILE',
		    Source: 'SOURCE',
		    Account: 'ACCOUNT',
		    AggregatedEntitlement: 'AGGREGATED_ENTITLEMENT',
		    InvalidCertifiableEntity: 'INVALID_CERTIFIABLE_ENTITY'
		};
		exports.DateCompareOperatorEnum = {
		    Lt: 'LT',
		    Lte: 'LTE',
		    Gt: 'GT',
		    Gte: 'GTE'
		};
		exports.DeleteSource202ResponseTypeEnum = {
		    TaskResult: 'TASK_RESULT'
		};
		/**
		 * Enum representing the currently supported document types.  Additional values may be added in the future without notice.
		 * @export
		 * @enum {string}
		 */
		exports.DocumentType = {
		    Accessprofile: 'accessprofile',
		    Accountactivity: 'accountactivity',
		    Account: 'account',
		    Aggregation: 'aggregation',
		    Entitlement: 'entitlement',
		    Event: 'event',
		    Identity: 'identity',
		    Role: 'role'
		};
		/**
		 * An enumeration of the types of DTOs supported within the IdentityNow infrastructure.
		 * @export
		 * @enum {string}
		 */
		exports.DtoType = {
		    AccountCorrelationConfig: 'ACCOUNT_CORRELATION_CONFIG',
		    AccessProfile: 'ACCESS_PROFILE',
		    AccessRequestApproval: 'ACCESS_REQUEST_APPROVAL',
		    Account: 'ACCOUNT',
		    Application: 'APPLICATION',
		    Campaign: 'CAMPAIGN',
		    CampaignFilter: 'CAMPAIGN_FILTER',
		    Certification: 'CERTIFICATION',
		    Cluster: 'CLUSTER',
		    ConnectorSchema: 'CONNECTOR_SCHEMA',
		    Entitlement: 'ENTITLEMENT',
		    GovernanceGroup: 'GOVERNANCE_GROUP',
		    Identity: 'IDENTITY',
		    IdentityProfile: 'IDENTITY_PROFILE',
		    IdentityRequest: 'IDENTITY_REQUEST',
		    LifecycleState: 'LIFECYCLE_STATE',
		    PasswordPolicy: 'PASSWORD_POLICY',
		    Role: 'ROLE',
		    Rule: 'RULE',
		    SodPolicy: 'SOD_POLICY',
		    Source: 'SOURCE',
		    Tag: 'TAG',
		    TagCategory: 'TAG_CATEGORY',
		    TaskResult: 'TASK_RESULT',
		    ReportResult: 'REPORT_RESULT',
		    SodViolation: 'SOD_VIOLATION',
		    AccountActivity: 'ACCOUNT_ACTIVITY',
		    Workgroup: 'WORKGROUP'
		};
		exports.EntitlementRefTypeEnum = {
		    Entitlement: 'ENTITLEMENT'
		};
		exports.EntitlementRef1TypeEnum = {
		    Entitlement: 'ENTITLEMENT'
		};
		exports.ExceptionCriteriaCriteriaListInnerTypeEnum = {
		    Entitlement: 'ENTITLEMENT'
		};
		/**
		 * The current state of execution.
		 * @export
		 * @enum {string}
		 */
		exports.ExecutionStatus = {
		    Executing: 'EXECUTING',
		    Verifying: 'VERIFYING',
		    Terminated: 'TERMINATED',
		    Completed: 'COMPLETED'
		};
		exports.ExpressionOperatorEnum = {
		    And: 'AND',
		    Equals: 'EQUALS'
		};
		exports.ExpressionChildrenInnerOperatorEnum = {
		    And: 'AND',
		    Equals: 'EQUALS'
		};
		/**
		 * Enum representing the currently supported filter types. Additional values may be added in the future without notice.
		 * @export
		 * @enum {string}
		 */
		exports.FilterType = {
		    Exists: 'EXISTS',
		    Range: 'RANGE',
		    Terms: 'TERMS'
		};
		/**
		 * OAuth2 Grant Type
		 * @export
		 * @enum {string}
		 */
		exports.GrantType = {
		    ClientCredentials: 'CLIENT_CREDENTIALS',
		    AuthorizationCode: 'AUTHORIZATION_CODE',
		    RefreshToken: 'REFRESH_TOKEN'
		};
		exports.IdentityProfileAllOfAuthoritativeSourceTypeEnum = {
		    Source: 'SOURCE'
		};
		exports.IdentityProfileAllOfOwnerTypeEnum = {
		    Identity: 'IDENTITY'
		};
		exports.IdentityProfileExportedObjectSelfTypeEnum = {
		    AccessProfile: 'ACCESS_PROFILE',
		    AccessRequestConfig: 'ACCESS_REQUEST_CONFIG',
		    AttrSyncSourceConfig: 'ATTR_SYNC_SOURCE_CONFIG',
		    AuthOrg: 'AUTH_ORG',
		    CampaignFilter: 'CAMPAIGN_FILTER',
		    FormDefinition: 'FORM_DEFINITION',
		    GovernanceGroup: 'GOVERNANCE_GROUP',
		    IdentityObjectConfig: 'IDENTITY_OBJECT_CONFIG',
		    IdentityProfile: 'IDENTITY_PROFILE',
		    LifecycleState: 'LIFECYCLE_STATE',
		    NotificationTemplate: 'NOTIFICATION_TEMPLATE',
		    PasswordPolicy: 'PASSWORD_POLICY',
		    PasswordSyncGroup: 'PASSWORD_SYNC_GROUP',
		    PublicIdentitiesConfig: 'PUBLIC_IDENTITIES_CONFIG',
		    Role: 'ROLE',
		    Rule: 'RULE',
		    Segment: 'SEGMENT',
		    ServiceDeskIntegration: 'SERVICE_DESK_INTEGRATION',
		    SodPolicy: 'SOD_POLICY',
		    Source: 'SOURCE',
		    Tag: 'TAG',
		    Transform: 'TRANSFORM',
		    TriggerSubscription: 'TRIGGER_SUBSCRIPTION',
		    Workflow: 'WORKFLOW'
		};
		exports.IdentityWithNewAccess1AccessRefsInnerTypeEnum = {
		    Entitlement: 'ENTITLEMENT'
		};
		exports.IdentityWithNewAccessAccessRefsInnerTypeEnum = {
		    Entitlement: 'ENTITLEMENT'
		};
		exports.ImportObjectTypeEnum = {
		    IdentityObjectConfig: 'IDENTITY_OBJECT_CONFIG',
		    IdentityProfile: 'IDENTITY_PROFILE',
		    Rule: 'RULE',
		    Source: 'SOURCE',
		    Transform: 'TRANSFORM',
		    TriggerSubscription: 'TRIGGER_SUBSCRIPTION'
		};
		/**
		 * Enum representing the currently supported indices. Additional values may be added in the future without notice.
		 * @export
		 * @enum {string}
		 */
		exports.Index = {
		    Accessprofiles: 'accessprofiles',
		    Accountactivities: 'accountactivities',
		    Entitlements: 'entitlements',
		    Events: 'events',
		    Identities: 'identities',
		    Roles: 'roles',
		    Star: '*'
		};
		exports.JsonPatchOperationOpEnum = {
		    Add: 'add',
		    Remove: 'remove',
		    Replace: 'replace',
		    Move: 'move',
		    Copy: 'copy',
		    Test: 'test'
		};
		exports.LifecyclestateDeletedTypeEnum = {
		    LifecycleState: 'LIFECYCLE_STATE'
		};
		/**
		 * An indicator of how the locale was selected. *DEFAULT* means the locale is the system default. *REQUEST* means the locale was selected from the request context (i.e., best match based on the *Accept-Language* header). Additional values may be added in the future without notice.
		 * @export
		 * @enum {string}
		 */
		exports.LocaleOrigin = {
		    Default: 'DEFAULT',
		    Request: 'REQUEST',
		    Null: 'null'
		};
		exports.ManualWorkItemDetailsCurrentOwnerTypeEnum = {
		    GovernanceGroup: 'GOVERNANCE_GROUP',
		    Identity: 'IDENTITY'
		};
		exports.ManualWorkItemDetailsOriginalOwnerTypeEnum = {
		    GovernanceGroup: 'GOVERNANCE_GROUP',
		    Identity: 'IDENTITY'
		};
		/**
		 * Indicates the state of the request processing for this item: * PENDING: The request for this item is awaiting processing. * APPROVED: The request for this item has been approved. * REJECTED: The request for this item was rejected. * EXPIRED: The request for this item expired with no action taken. * CANCELLED: The request for this item was cancelled with no user action. * ARCHIVED: The request for this item has been archived after completion.
		 * @export
		 * @enum {string}
		 */
		exports.ManualWorkItemState = {
		    Pending: 'PENDING',
		    Approved: 'APPROVED',
		    Rejected: 'REJECTED',
		    Expired: 'EXPIRED',
		    Cancelled: 'CANCELLED',
		    Archived: 'ARCHIVED'
		};
		/**
		 * Enum representing the currently supported metric aggregation types. Additional values may be added in the future without notice.
		 * @export
		 * @enum {string}
		 */
		exports.MetricType = {
		    Count: 'COUNT',
		    UniqueCount: 'UNIQUE_COUNT',
		    Avg: 'AVG',
		    Sum: 'SUM',
		    Median: 'MEDIAN',
		    Min: 'MIN',
		    Max: 'MAX'
		};
		/**
		 * | Construct       | Date Time Pattern | Description | | ---------       | ----------------- | ----------- | | ISO8601         | `yyyy-MM-dd\'T\'HH:mm:ss.SSSX` | The ISO8601 standard. |           | LDAP            | `yyyyMMddHHmmss.Z`           | The LDAP standard.    | | PEOPLE_SOFT     | `MM/dd/yyyy`                 | The date format People Soft uses. | | EPOCH_TIME_JAVA | # ms from midnight, January 1st, 1970 | The incoming date value as elapsed time in milliseconds from midnight, January 1st, 1970. | | EPOCH_TIME_WIN32| # intervals of 100ns from midnight, January 1st, 1601 | The incoming date value as elapsed time in 100-nanosecond intervals from midnight, January 1st, 1601. |
		 * @export
		 * @enum {string}
		 */
		exports.NamedConstructs = {
		    Iso8601: 'ISO8601',
		    Ldap: 'LDAP',
		    PeopleSoft: 'PEOPLE_SOFT',
		    EpochTimeJava: 'EPOCH_TIME_JAVA',
		    EpochTimeWin32: 'EPOCH_TIME_WIN32'
		};
		exports.NonEmployeeBulkUploadJobStatusEnum = {
		    Pending: 'PENDING',
		    InProgress: 'IN_PROGRESS',
		    Completed: 'COMPLETED',
		    Error: 'ERROR'
		};
		exports.NonEmployeeBulkUploadStatusStatusEnum = {
		    Pending: 'PENDING',
		    InProgress: 'IN_PROGRESS',
		    Completed: 'COMPLETED',
		    Error: 'ERROR'
		};
		/**
		 * Identifies if the identity is a normal identity or a governance group
		 * @export
		 * @enum {string}
		 */
		exports.NonEmployeeIdentityDtoType = {
		    GovernanceGroup: 'GOVERNANCE_GROUP',
		    Identity: 'IDENTITY'
		};
		/**
		 * Enum representing the type of data a schema attribute accepts.
		 * @export
		 * @enum {string}
		 */
		exports.NonEmployeeSchemaAttributeType = {
		    Text: 'TEXT',
		    Date: 'DATE',
		    Identity: 'IDENTITY'
		};
		/**
		 * Operation on a specific criteria
		 * @export
		 * @enum {string}
		 */
		exports.Operation = {
		    Equals: 'EQUALS',
		    NotEquals: 'NOT_EQUALS',
		    Contains: 'CONTAINS',
		    StartsWith: 'STARTS_WITH',
		    EndsWith: 'ENDS_WITH',
		    And: 'AND',
		    Or: 'OR',
		    Null: 'null'
		};
		exports.OrphanUncorrelatedReportArgumentsSelectedFormatsEnum = {
		    Csv: 'CSV',
		    Pdf: 'PDF'
		};
		exports.OwnerDtoTypeEnum = {
		    Identity: 'IDENTITY'
		};
		exports.OwnerReferenceTypeEnum = {
		    Identity: 'IDENTITY'
		};
		exports.OwnerReferenceSegmentsTypeEnum = {
		    Identity: 'IDENTITY'
		};
		exports.PasswordChangeResponseStateEnum = {
		    InProgress: 'IN_PROGRESS',
		    Finished: 'FINISHED',
		    Failed: 'FAILED'
		};
		exports.PasswordStatusStateEnum = {
		    InProgress: 'IN_PROGRESS',
		    Finished: 'FINISHED',
		    Failed: 'FAILED'
		};
		exports.PatOwnerTypeEnum = {
		    Identity: 'IDENTITY'
		};
		/**
		 * Enum represents action that is being processed on an approval.
		 * @export
		 * @enum {string}
		 */
		exports.PendingApprovalAction = {
		    Approved: 'APPROVED',
		    Rejected: 'REJECTED',
		    Forwarded: 'FORWARDED'
		};
		exports.PendingApprovalOwnerTypeEnum = {
		    Identity: 'IDENTITY'
		};
		exports.PreApprovalTriggerDetailsDecisionEnum = {
		    Approved: 'APPROVED',
		    Rejected: 'REJECTED'
		};
		exports.ProvisioningConfigManagedResourceRefsInnerTypeEnum = {
		    Source: 'SOURCE'
		};
		/**
		 * Supported operations on ProvisioningCriteria
		 * @export
		 * @enum {string}
		 */
		exports.ProvisioningCriteriaOperation = {
		    Equals: 'EQUALS',
		    NotEquals: 'NOT_EQUALS',
		    Contains: 'CONTAINS',
		    Has: 'HAS',
		    And: 'AND',
		    Or: 'OR'
		};
		/**
		 * Provisioning state of an account activity item
		 * @export
		 * @enum {string}
		 */
		exports.ProvisioningState = {
		    Pending: 'PENDING',
		    Finished: 'FINISHED',
		    Unverifiable: 'UNVERIFIABLE',
		    Commited: 'COMMITED',
		    Failed: 'FAILED',
		    Retry: 'RETRY'
		};
		exports.PublicIdentityIdentityStateEnum = {
		    Active: 'ACTIVE',
		    InactiveShortTerm: 'INACTIVE_SHORT_TERM',
		    InactiveLongTerm: 'INACTIVE_LONG_TERM',
		    Null: 'null'
		};
		/**
		 * The type of query to use.  By default, the `SAILPOINT` query type is used, which requires the `query` object to be defined in the request body. To use the `queryDsl` or `typeAheadQuery` objects in the request, you must set the type to `DSL` or `TYPEAHEAD` accordingly. Additional values may be added in the future without notice.
		 * @export
		 * @enum {string}
		 */
		exports.QueryType = {
		    Dsl: 'DSL',
		    Sailpoint: 'SAILPOINT',
		    Text: 'TEXT',
		    Typeahead: 'TYPEAHEAD'
		};
		exports.ReassignReferenceTypeEnum = {
		    TargetSummary: 'TARGET_SUMMARY',
		    Item: 'ITEM',
		    IdentitySummary: 'IDENTITY_SUMMARY'
		};
		exports.ReassignmentReferenceTypeEnum = {
		    TargetSummary: 'TARGET_SUMMARY',
		    Item: 'ITEM',
		    IdentitySummary: 'IDENTITY_SUMMARY'
		};
		/**
		 * The approval reassignment type.  * MANUAL_REASSIGNMENT: An approval with this reassignment type has been specifically reassigned by the approval task\'s owner, from their queue to someone else\'s.  * AUTOMATIC_REASSIGNMENT: An approval with this reassignment type has been automatically reassigned from another approver\'s queue, according to that approver\'s reassignment configuration. The approver\'s reassignment configuration may be set up to automatically reassign approval tasks for a defined (or possibly open-ended) period of time. * AUTO_ESCALATION: An approval with this reassignment type has been automatically reassigned from another approver\'s queue, according to the request\'s escalation configuration. For more information about escalation configuration, refer to [Setting Global Reminders and Escalation Policies](https://documentation.sailpoint.com/saas/help/requests/config_emails.html). * SELF_REVIEW_DELEGATION: An approval with this reassignment type has been automatically reassigned by the system to prevent self-review. This helps prevent situations like a requester being tasked with approving their own request. For more information about preventing self-review, refer to [Self-review Prevention](https://documentation.sailpoint.com/saas/help/users/work_reassignment.html#self-review-prevention) and [Preventing Self-approval](https://documentation.sailpoint.com/saas/help/requests/config_ap_roles.html#preventing-self-approval).
		 * @export
		 * @enum {string}
		 */
		exports.ReassignmentType = {
		    ManualReassignment: 'MANUAL_REASSIGNMENT',
		    AutomaticReassignment: 'AUTOMATIC_REASSIGNMENT',
		    AutoEscalation: 'AUTO_ESCALATION',
		    SelfReviewDelegation: 'SELF_REVIEW_DELEGATION'
		};
		exports.ReportDetailsReportTypeEnum = {
		    Accounts: 'ACCOUNTS',
		    IdentitiesDetails: 'IDENTITIES_DETAILS',
		    Identities: 'IDENTITIES',
		    IdentityProfileIdentityError: 'IDENTITY_PROFILE_IDENTITY_ERROR',
		    OrphanIdentities: 'ORPHAN_IDENTITIES',
		    SearchExport: 'SEARCH_EXPORT',
		    UncorrelatedAccounts: 'UNCORRELATED_ACCOUNTS'
		};
		exports.ReportResultReferenceTypeEnum = {
		    ReportResult: 'REPORT_RESULT'
		};
		exports.ReportResultReferenceStatusEnum = {
		    Success: 'SUCCESS',
		    Warning: 'WARNING',
		    Error: 'ERROR',
		    Terminated: 'TERMINATED',
		    TempError: 'TEMP_ERROR',
		    Pending: 'PENDING'
		};
		exports.ReportResultReferenceAllOfStatusEnum = {
		    Success: 'SUCCESS',
		    Warning: 'WARNING',
		    Error: 'ERROR',
		    Terminated: 'TERMINATED',
		    TempError: 'TEMP_ERROR',
		    Pending: 'PENDING'
		};
		exports.ReportResultsReportTypeEnum = {
		    Accounts: 'ACCOUNTS',
		    IdentitiesDetails: 'IDENTITIES_DETAILS',
		    Identities: 'IDENTITIES',
		    IdentityProfileIdentityError: 'IDENTITY_PROFILE_IDENTITY_ERROR',
		    OrphanIdentities: 'ORPHAN_IDENTITIES',
		    SearchExport: 'SEARCH_EXPORT',
		    UncorrelatedAccounts: 'UNCORRELATED_ACCOUNTS'
		};
		exports.ReportResultsStatusEnum = {
		    Success: 'SUCCESS',
		    Failure: 'FAILURE',
		    Warning: 'WARNING',
		    Terminated: 'TERMINATED'
		};
		exports.ReportResultsAvailableFormatsEnum = {
		    Csv: 'CSV',
		    Pdf: 'PDF'
		};
		/**
		 * type of a Report
		 * @export
		 * @enum {string}
		 */
		exports.ReportType = {
		    CampaignCompositionReport: 'CAMPAIGN_COMPOSITION_REPORT',
		    CampaignRemediationStatusReport: 'CAMPAIGN_REMEDIATION_STATUS_REPORT',
		    CampaignStatusReport: 'CAMPAIGN_STATUS_REPORT',
		    CertificationSignoffReport: 'CERTIFICATION_SIGNOFF_REPORT'
		};
		exports.RequestableObjectReferenceTypeEnum = {
		    AccessProfile: 'ACCESS_PROFILE',
		    Role: 'ROLE',
		    Entitlement: 'ENTITLEMENT'
		};
		/**
		 * Status indicating the ability of an access request for the object to be made by or on behalf of the identity specified by *identity-id*. *AVAILABLE* indicates the object is available to request. *PENDING* indicates the object is unavailable because the identity has a pending request in flight. *ASSIGNED* indicates the object is unavailable because the identity already has the indicated role or access profile. If *identity-id* is not specified (allowed only for admin users), then status will be *AVAILABLE* for all results.
		 * @export
		 * @enum {string}
		 */
		exports.RequestableObjectRequestStatus = {
		    Available: 'AVAILABLE',
		    Pending: 'PENDING',
		    Assigned: 'ASSIGNED',
		    Null: 'null'
		};
		/**
		 * The currently supported requestable object types.
		 * @export
		 * @enum {string}
		 */
		exports.RequestableObjectType = {
		    AccessProfile: 'ACCESS_PROFILE',
		    Role: 'ROLE',
		    Entitlement: 'ENTITLEMENT'
		};
		exports.RequestedItemStatusTypeEnum = {
		    AccessProfile: 'ACCESS_PROFILE',
		    Role: 'ROLE',
		    Entitlement: 'ENTITLEMENT',
		    Null: 'null'
		};
		exports.RequestedItemStatusPreApprovalTriggerDetailsDecisionEnum = {
		    Approved: 'APPROVED',
		    Rejected: 'REJECTED'
		};
		/**
		 * Indicates the state of an access request: * EXECUTING: The request is executing, which indicates the system is doing some processing. * REQUEST_COMPLETED: Indicates the request  has been completed. * CANCELLED: The request was cancelled with no user input. * TERMINATED: The request has been terminated before it was able to complete. * PROVISIONING_VERIFICATION_PENDING: The request has finished any approval steps and provisioning is waiting to be verified. * REJECTED: The request was rejected. * PROVISIONING_FAILED: The request has failed to complete. * NOT_ALL_ITEMS_PROVISIONED: One or more of the requested items failed to complete, but there were one or more  successes. * ERROR: An error occurred during request processing.
		 * @export
		 * @enum {string}
		 */
		exports.RequestedItemStatusRequestState = {
		    Executing: 'EXECUTING',
		    RequestCompleted: 'REQUEST_COMPLETED',
		    Cancelled: 'CANCELLED',
		    Terminated: 'TERMINATED',
		    ProvisioningVerificationPending: 'PROVISIONING_VERIFICATION_PENDING',
		    Rejected: 'REJECTED',
		    ProvisioningFailed: 'PROVISIONING_FAILED',
		    NotAllItemsProvisioned: 'NOT_ALL_ITEMS_PROVISIONED',
		    Error: 'ERROR'
		};
		exports.RequestedItemStatusSodViolationContextStateEnum = {
		    Success: 'SUCCESS',
		    Error: 'ERROR',
		    Null: 'null'
		};
		exports.ReviewerTypeEnum = {
		    Identity: 'IDENTITY'
		};
		/**
		 * Type which indicates how a particular Identity obtained a particular Role
		 * @export
		 * @enum {string}
		 */
		exports.RoleAssignmentSourceType = {
		    AccessRequest: 'ACCESS_REQUEST',
		    RoleMembership: 'ROLE_MEMBERSHIP'
		};
		/**
		 * Indicates whether the associated criteria represents an expression on identity attributes, account attributes, or entitlements, respectively.
		 * @export
		 * @enum {string}
		 */
		exports.RoleCriteriaKeyType = {
		    Identity: 'IDENTITY',
		    Account: 'ACCOUNT',
		    Entitlement: 'ENTITLEMENT'
		};
		/**
		 * An operation
		 * @export
		 * @enum {string}
		 */
		exports.RoleCriteriaOperation = {
		    Equals: 'EQUALS',
		    NotEquals: 'NOT_EQUALS',
		    Contains: 'CONTAINS',
		    StartsWith: 'STARTS_WITH',
		    EndsWith: 'ENDS_WITH',
		    And: 'AND',
		    Or: 'OR'
		};
		/**
		 * This enum characterizes the type of a Role\'s membership selector. Only the following two are fully supported:  STANDARD: Indicates that Role membership is defined in terms of a criteria expression  IDENTITY_LIST: Indicates that Role membership is conferred on the specific identities listed
		 * @export
		 * @enum {string}
		 */
		exports.RoleMembershipSelectorType = {
		    Standard: 'STANDARD',
		    IdentityList: 'IDENTITY_LIST'
		};
		exports.ScheduleTypeEnum = {
		    Weekly: 'WEEKLY',
		    Monthly: 'MONTHLY',
		    Annually: 'ANNUALLY',
		    Calendar: 'CALENDAR'
		};
		exports.ScheduleDaysTypeEnum = {
		    List: 'LIST',
		    Range: 'RANGE'
		};
		exports.ScheduleHoursTypeEnum = {
		    List: 'LIST',
		    Range: 'RANGE'
		};
		exports.ScheduleMonthsTypeEnum = {
		    List: 'LIST',
		    Range: 'RANGE'
		};
		/**
		 * Enum representing the currently supported schedule types.  Additional values may be added in the future without notice.
		 * @export
		 * @enum {string}
		 */
		exports.ScheduleType = {
		    Daily: 'DAILY',
		    Weekly: 'WEEKLY',
		    Monthly: 'MONTHLY',
		    Calendar: 'CALENDAR',
		    Annually: 'ANNUALLY'
		};
		exports.ScheduledSearchAllOfOwnerTypeEnum = {
		    Identity: 'IDENTITY'
		};
		/**
		 * Enum representing the currently supported filter aggregation types. Additional values may be added in the future without notice.
		 * @export
		 * @enum {string}
		 */
		exports.SearchFilterType = {
		    Term: 'TERM'
		};
		exports.SearchScheduleRecipientsInnerTypeEnum = {
		    Identity: 'IDENTITY'
		};
		/**
		 * Enum representing the currently supported selector types.  LIST - the *values* array contains one or more distinct values.  RANGE - the *values* array contains two values: the start and end of the range, inclusive.  Additional values may be added in the future without notice.
		 * @export
		 * @enum {string}
		 */
		exports.SelectorType = {
		    List: 'LIST',
		    Range: 'RANGE'
		};
		exports.ServiceDeskSourceTypeEnum = {
		    Source: 'SOURCE'
		};
		exports.SlimCampaignTypeEnum = {
		    Manager: 'MANAGER',
		    SourceOwner: 'SOURCE_OWNER',
		    Search: 'SEARCH',
		    RoleComposition: 'ROLE_COMPOSITION'
		};
		exports.SlimCampaignStatusEnum = {
		    Pending: 'PENDING',
		    Staged: 'STAGED',
		    Canceling: 'CANCELING',
		    Activating: 'ACTIVATING',
		    Active: 'ACTIVE',
		    Completing: 'COMPLETING',
		    Completed: 'COMPLETED',
		    Error: 'ERROR',
		    Archived: 'ARCHIVED'
		};
		exports.SlimCampaignCorrelatedStatusEnum = {
		    Correlated: 'CORRELATED',
		    Uncorrelated: 'UNCORRELATED'
		};
		exports.SodPolicyStateEnum = {
		    Enforced: 'ENFORCED',
		    NotEnforced: 'NOT_ENFORCED'
		};
		exports.SodPolicyTypeEnum = {
		    General: 'GENERAL',
		    ConflictingAccessBased: 'CONFLICTING_ACCESS_BASED'
		};
		exports.SodPolicyDtoTypeEnum = {
		    SodPolicy: 'SOD_POLICY'
		};
		exports.SodRecipientTypeEnum = {
		    Identity: 'IDENTITY'
		};
		exports.SodReportResultDtoTypeEnum = {
		    ReportResult: 'REPORT_RESULT'
		};
		exports.SodViolationContextCheckCompletedStateEnum = {
		    Success: 'SUCCESS',
		    Error: 'ERROR',
		    Null: 'null'
		};
		exports.SourceAccountCorrelationConfigTypeEnum = {
		    AccountCorrelationConfig: 'ACCOUNT_CORRELATION_CONFIG'
		};
		exports.SourceAccountCorrelationRuleTypeEnum = {
		    Rule: 'RULE'
		};
		exports.SourceBeforeProvisioningRuleTypeEnum = {
		    Rule: 'RULE'
		};
		exports.SourceClusterTypeEnum = {
		    Cluster: 'CLUSTER'
		};
		exports.SourceClusterDtoTypeEnum = {
		    Cluster: 'CLUSTER'
		};
		/**
		 * Optional features that can be supported by an source. * AUTHENTICATE: The source supports pass-through authentication. * COMPOSITE: The source supports composite source creation. * DIRECT_PERMISSIONS: The source supports returning DirectPermissions. * DISCOVER_SCHEMA: The source supports discovering schemas for users and groups. * ENABLE The source supports reading if an account is enabled or disabled. * MANAGER_LOOKUP: The source supports looking up managers as they are encountered in a feed. This is the opposite of NO_RANDOM_ACCESS. * NO_RANDOM_ACCESS: The source does not support random access and the getObject() methods should not be called and expected to perform. * PROXY: The source can serve as a proxy for another source. When an source has a proxy, all connector calls made with that source are redirected through the connector for the proxy source. * SEARCH * TEMPLATE * UNLOCK: The source supports reading if an account is locked or unlocked. * UNSTRUCTURED_TARGETS: The source supports returning unstructured Targets. * SHAREPOINT_TARGET: The source supports returning unstructured Target data for SharePoint. It will be typically used by AD, LDAP sources. * PROVISIONING: The source can both read and write accounts. Having this feature implies that the provision() method is implemented. It also means that direct and target permissions can also be provisioned if they can be returned by aggregation. * GROUP_PROVISIONING: The source can both read and write groups. Having this feature implies that the provision() method is implemented. * SYNC_PROVISIONING: The source can provision accounts synchronously. * PASSWORD: The source can provision password changes. Since sources can never read passwords, this is should only be used in conjunction with the PROVISIONING feature. * CURRENT_PASSWORD: Some source types support verification of the current password * ACCOUNT_ONLY_REQUEST: The source supports requesting accounts without entitlements. * ADDITIONAL_ACCOUNT_REQUEST: The source supports requesting additional accounts. * NO_AGGREGATION: A source that does not support aggregation. * GROUPS_HAVE_MEMBERS: The source models group memberships with a member attribute on the group object rather than a groups attribute on the account object. This effects the implementation of delta account aggregation. * NO_PERMISSIONS_PROVISIONING: Indicates that the connector cannot provision direct or target permissions for accounts. When DIRECT_PERMISSIONS and PROVISIONING features are present, it is assumed that the connector can also provision direct permissions. This feature disables that assumption and causes permission request to be converted to work items for accounts. * NO_GROUP_PERMISSIONS_PROVISIONING: Indicates that the connector cannot provision direct or target permissions for groups. When DIRECT_PERMISSIONS and PROVISIONING features are present, it is assumed that the connector can also provision direct permissions. This feature disables that assumption and causes permission request to be converted to work items for groups. * NO_UNSTRUCTURED_TARGETS_PROVISIONING: This string will be replaced by NO_GROUP_PERMISSIONS_PROVISIONING and NO_PERMISSIONS_PROVISIONING. * NO_DIRECT_PERMISSIONS_PROVISIONING: This string will be replaced by NO_GROUP_PERMISSIONS_PROVISIONING and NO_PERMISSIONS_PROVISIONING.
		 * @export
		 * @enum {string}
		 */
		exports.SourceFeature = {
		    Authenticate: 'AUTHENTICATE',
		    Composite: 'COMPOSITE',
		    DirectPermissions: 'DIRECT_PERMISSIONS',
		    DiscoverSchema: 'DISCOVER_SCHEMA',
		    Enable: 'ENABLE',
		    ManagerLookup: 'MANAGER_LOOKUP',
		    NoRandomAccess: 'NO_RANDOM_ACCESS',
		    Proxy: 'PROXY',
		    Search: 'SEARCH',
		    Template: 'TEMPLATE',
		    Unlock: 'UNLOCK',
		    UnstructuredTargets: 'UNSTRUCTURED_TARGETS',
		    SharepointTarget: 'SHAREPOINT_TARGET',
		    Provisioning: 'PROVISIONING',
		    GroupProvisioning: 'GROUP_PROVISIONING',
		    SyncProvisioning: 'SYNC_PROVISIONING',
		    Password: 'PASSWORD',
		    CurrentPassword: 'CURRENT_PASSWORD',
		    AccountOnlyRequest: 'ACCOUNT_ONLY_REQUEST',
		    AdditionalAccountRequest: 'ADDITIONAL_ACCOUNT_REQUEST',
		    NoAggregation: 'NO_AGGREGATION',
		    GroupsHaveMembers: 'GROUPS_HAVE_MEMBERS',
		    NoPermissionsProvisioning: 'NO_PERMISSIONS_PROVISIONING',
		    NoGroupPermissionsProvisioning: 'NO_GROUP_PERMISSIONS_PROVISIONING',
		    NoUnstructuredTargetsProvisioning: 'NO_UNSTRUCTURED_TARGETS_PROVISIONING',
		    NoDirectPermissionsProvisioning: 'NO_DIRECT_PERMISSIONS_PROVISIONING',
		    PreferUuid: 'PREFER_UUID'
		};
		exports.SourceHealthDtoStatusEnum = {
		    ErrorCluster: 'SOURCE_STATE_ERROR_CLUSTER',
		    ErrorSource: 'SOURCE_STATE_ERROR_SOURCE',
		    ErrorVa: 'SOURCE_STATE_ERROR_VA',
		    FailureCluster: 'SOURCE_STATE_FAILURE_CLUSTER',
		    FailureSource: 'SOURCE_STATE_FAILURE_SOURCE',
		    Healthy: 'SOURCE_STATE_HEALTHY',
		    UncheckedCluster: 'SOURCE_STATE_UNCHECKED_CLUSTER',
		    UncheckedClusterNoSources: 'SOURCE_STATE_UNCHECKED_CLUSTER_NO_SOURCES',
		    UncheckedSource: 'SOURCE_STATE_UNCHECKED_SOURCE',
		    UncheckedSourceNoAccounts: 'SOURCE_STATE_UNCHECKED_SOURCE_NO_ACCOUNTS'
		};
		exports.SourceManagementWorkgroupTypeEnum = {
		    GovernanceGroup: 'GOVERNANCE_GROUP'
		};
		exports.SourceManagerCorrelationRuleTypeEnum = {
		    Rule: 'RULE'
		};
		exports.SourceOwnerTypeEnum = {
		    Identity: 'IDENTITY'
		};
		exports.SourcePasswordPoliciesInnerTypeEnum = {
		    PasswordPolicy: 'PASSWORD_POLICY'
		};
		exports.SourceSchemasInnerTypeEnum = {
		    ConnectorSchema: 'CONNECTOR_SCHEMA'
		};
		exports.SourceUsageStatusStatusEnum = {
		    Complete: 'COMPLETE',
		    Incomplete: 'INCOMPLETE'
		};
		exports.TaggedObjectDtoTypeEnum = {
		    AccessProfile: 'ACCESS_PROFILE',
		    Application: 'APPLICATION',
		    Campaign: 'CAMPAIGN',
		    Entitlement: 'ENTITLEMENT',
		    Identity: 'IDENTITY',
		    Role: 'ROLE',
		    SodPolicy: 'SOD_POLICY',
		    Source: 'SOURCE'
		};
		exports.TaskResultDetailsTypeEnum = {
		    Quartz: 'QUARTZ',
		    Qpoc: 'QPOC',
		    Mentos: 'MENTOS',
		    QueuedTask: 'QUEUED_TASK'
		};
		exports.TaskResultDetailsReportTypeEnum = {
		    Accounts: 'ACCOUNTS',
		    IdentitiesDetails: 'IDENTITIES_DETAILS',
		    Identities: 'IDENTITIES',
		    IdentityProfileIdentityError: 'IDENTITY_PROFILE_IDENTITY_ERROR',
		    OrphanIdentities: 'ORPHAN_IDENTITIES',
		    SearchExport: 'SEARCH_EXPORT',
		    UncorrelatedAccounts: 'UNCORRELATED_ACCOUNTS'
		};
		exports.TaskResultDetailsCompletionStatusEnum = {
		    Success: 'SUCCESS',
		    Warning: 'WARNING',
		    Error: 'ERROR',
		    Terminated: 'TERMINATED',
		    TempError: 'TEMP_ERROR'
		};
		exports.TaskResultDetailsMessagesInnerTypeEnum = {
		    Info: 'INFO',
		    Warn: 'WARN',
		    Error: 'ERROR'
		};
		exports.TaskResultDtoTypeEnum = {
		    TaskResult: 'TASK_RESULT'
		};
		exports.TaskResultSimplifiedCompletionStatusEnum = {
		    Success: 'Success',
		    Warning: 'Warning',
		    Error: 'Error',
		    Terminated: 'Terminated',
		    TempError: 'TempError'
		};
		exports.TransformTypeEnum = {
		    AccountAttribute: 'accountAttribute',
		    Base64Decode: 'base64Decode',
		    Base64Encode: 'base64Encode',
		    Concat: 'concat',
		    Conditional: 'conditional',
		    DateCompare: 'dateCompare',
		    DateFormat: 'dateFormat',
		    DateMath: 'dateMath',
		    DecomposeDiacriticalMarks: 'decomposeDiacriticalMarks',
		    E164phone: 'e164phone',
		    FirstValid: 'firstValid',
		    Rule: 'rule',
		    IdentityAttribute: 'identityAttribute',
		    IndexOf: 'indexOf',
		    Iso3166: 'iso3166',
		    LastIndexOf: 'lastIndexOf',
		    LeftPad: 'leftPad',
		    Lookup: 'lookup',
		    Lower: 'lower',
		    NormalizeNames: 'normalizeNames',
		    RandomAlphaNumeric: 'randomAlphaNumeric',
		    RandomNumeric: 'randomNumeric',
		    Reference: 'reference',
		    ReplaceAll: 'replaceAll',
		    Replace: 'replace',
		    RightPad: 'rightPad',
		    Split: 'split',
		    Static: 'static',
		    Substring: 'substring',
		    Trim: 'trim',
		    Upper: 'upper',
		    UsernameGenerator: 'usernameGenerator',
		    Uuid: 'uuid'
		};
		exports.TransformReadTypeEnum = {
		    AccountAttribute: 'accountAttribute',
		    Base64Decode: 'base64Decode',
		    Base64Encode: 'base64Encode',
		    Concat: 'concat',
		    Conditional: 'conditional',
		    DateCompare: 'dateCompare',
		    DateFormat: 'dateFormat',
		    DateMath: 'dateMath',
		    DecomposeDiacriticalMarks: 'decomposeDiacriticalMarks',
		    E164phone: 'e164phone',
		    FirstValid: 'firstValid',
		    Rule: 'rule',
		    IdentityAttribute: 'identityAttribute',
		    IndexOf: 'indexOf',
		    Iso3166: 'iso3166',
		    LastIndexOf: 'lastIndexOf',
		    LeftPad: 'leftPad',
		    Lookup: 'lookup',
		    Lower: 'lower',
		    NormalizeNames: 'normalizeNames',
		    RandomAlphaNumeric: 'randomAlphaNumeric',
		    RandomNumeric: 'randomNumeric',
		    Reference: 'reference',
		    ReplaceAll: 'replaceAll',
		    Replace: 'replace',
		    RightPad: 'rightPad',
		    Split: 'split',
		    Static: 'static',
		    Substring: 'substring',
		    Trim: 'trim',
		    Upper: 'upper',
		    UsernameGenerator: 'usernameGenerator',
		    Uuid: 'uuid'
		};
		exports.UpdateDetailStatusEnum = {
		    Error: 'ERROR',
		    Updated: 'UPDATED',
		    Unchanged: 'UNCHANGED',
		    Skipped: 'SKIPPED'
		};
		/**
		 * The type of provisioning policy usage.  In IdentityNow, a source can support various provisioning operations. For example, when a joiner is added to a source, this may trigger both CREATE and UPDATE provisioning operations.  Each usage type is considered a provisioning policy.  A source can have any number of these provisioning policies defined.  These are the common usage types:  CREATE - This usage type relates to \'Create Account Profile\', the provisioning template for the account to be created. For example, this would be used for a joiner on a source.   UPDATE - This usage type relates to \'Update Account Profile\', the provisioning template for the \'Update\' connector operations. For example, this would be used for an attribute sync on a source. ENABLE - This usage type relates to \'Enable Account Profile\', the provisioning template for the account to be enabled. For example, this could be used for a joiner on a source once the joiner\'s account is created.  DISABLE - This usage type relates to \'Disable Account Profile\', the provisioning template for the account to be disabled. For example, this could be used when a leaver is removed temporarily from a source.  You can use these four usage types for all your provisioning policy needs.
		 * @export
		 * @enum {string}
		 */
		exports.UsageType = {
		    Create: 'CREATE',
		    Update: 'UPDATE',
		    Enable: 'ENABLE',
		    Disable: 'DISABLE',
		    Delete: 'DELETE',
		    Assign: 'ASSIGN',
		    Unassign: 'UNASSIGN',
		    CreateGroup: 'CREATE_GROUP',
		    UpdateGroup: 'UPDATE_GROUP',
		    DeleteGroup: 'DELETE_GROUP',
		    Register: 'REGISTER',
		    CreateIdentity: 'CREATE_IDENTITY',
		    UpdateIdentity: 'UPDATE_IDENTITY',
		    EditGroup: 'EDIT_GROUP',
		    Unlock: 'UNLOCK',
		    ChangePassword: 'CHANGE_PASSWORD'
		};
		exports.V3ConnectorDtoStatusEnum = {
		    Deprecated: 'DEPRECATED',
		    Development: 'DEVELOPMENT',
		    Demo: 'DEMO',
		    Released: 'RELEASED'
		};
		exports.V3CreateConnectorDtoStatusEnum = {
		    Development: 'DEVELOPMENT',
		    Demo: 'DEMO',
		    Released: 'RELEASED'
		};
		exports.ViolationContextPolicyTypeEnum = {
		    Entitlement: 'ENTITLEMENT'
		};
		exports.ViolationOwnerAssignmentConfigAssignmentRuleEnum = {
		    Manager: 'MANAGER',
		    Static: 'STATIC',
		    Null: 'null'
		};
		exports.ViolationOwnerAssignmentConfigOwnerRefTypeEnum = {
		    Identity: 'IDENTITY'
		};
		/**
		 * The state of a work item
		 * @export
		 * @enum {string}
		 */
		exports.WorkItemState = {
		    Finished: 'FINISHED',
		    Rejected: 'REJECTED',
		    Returned: 'RETURNED',
		    Expired: 'EXPIRED',
		    Pending: 'PENDING',
		    Canceled: 'CANCELED',
		    Null: 'null'
		};
		/**
		 * The state of a work item
		 * @export
		 * @enum {string}
		 */
		exports.WorkItemStateManualWorkItems = {
		    Finished: 'Finished',
		    Rejected: 'Rejected',
		    Returned: 'Returned',
		    Expired: 'Expired',
		    Pending: 'Pending',
		    Canceled: 'Canceled'
		};
		/**
		 * The type of the work item
		 * @export
		 * @enum {string}
		 */
		exports.WorkItemTypeManualWorkItems = {
		    Generic: 'Generic',
		    Certification: 'Certification',
		    Remediation: 'Remediation',
		    Delegation: 'Delegation',
		    Approval: 'Approval',
		    ViolationReview: 'ViolationReview',
		    Form: 'Form',
		    PolicyVioloation: 'PolicyVioloation',
		    Challenge: 'Challenge',
		    ImpactAnalysis: 'ImpactAnalysis',
		    Signoff: 'Signoff',
		    Event: 'Event',
		    ManualAction: 'ManualAction',
		    Test: 'Test'
		};
		/**
		 * AccessProfilesApi - axios parameter creator
		 * @export
		 */
		var AccessProfilesApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * This API creates an Access Profile. A token with API, ORG_ADMIN, ROLE_ADMIN, ROLE_SUBADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API. In addition, a token with only ROLE_SUBADMIN or SOURCE_SUBADMIN authority must be associated with the Access Profile\'s Source. The maximum supported length for the description field is 2000 characters. Longer descriptions will be preserved for existing access profiles, however, any new access profiles as well as any updates to existing descriptions will be limited to 2000 characters.
		         * @summary Create an Access Profile
		         * @param {AccessProfile} accessProfile
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createAccessProfile: function (accessProfile, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'accessProfile' is not null or undefined
		                            (0, common_1.assertParamExists)('createAccessProfile', 'accessProfile', accessProfile);
		                            localVarPath = "/access-profiles";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(accessProfile, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API deletes an existing Access Profile.  The Access Profile must not be in use, for example, Access Profile can not be deleted if they belong to an Application, Life Cycle State or a Role. If it is, a 400 error is returned.  A token with API, ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to invoke this API. In addition, a SOURCE_SUBADMIN token must be able to administer the Source associated with the Access Profile.
		         * @summary Delete the specified Access Profile
		         * @param {string} id ID of the Access Profile to delete
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteAccessProfile: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('deleteAccessProfile', 'id', id);
		                            localVarPath = "/access-profiles/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'DELETE' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API initiates a bulk deletion of one or more Access Profiles.  By default, if any of the indicated Access Profiles are in use, no deletions will be performed and the **inUse** field of the response indicates the usages that must be removed first. If the request field **bestEffortOnly** is **true**, however, usages are reported in the **inUse** response field but all other indicated Access Profiles will be deleted.  A token with API, ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API. In addition, a SOURCE_SUBADMIN may only use this API to delete Access Profiles which are associated with Sources they are able to administer.
		         * @summary Delete Access Profile(s)
		         * @param {AccessProfileBulkDeleteRequest} accessProfileBulkDeleteRequest
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteAccessProfilesInBulk: function (accessProfileBulkDeleteRequest, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'accessProfileBulkDeleteRequest' is not null or undefined
		                            (0, common_1.assertParamExists)('deleteAccessProfilesInBulk', 'accessProfileBulkDeleteRequest', accessProfileBulkDeleteRequest);
		                            localVarPath = "/access-profiles/bulk-delete";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(accessProfileBulkDeleteRequest, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns an Access Profile by its ID.  A token with API, ORG_ADMIN, ROLE_ADMIN, ROLE_SUBADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		         * @summary Get an Access Profile
		         * @param {string} id ID of the Access Profile
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getAccessProfile: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getAccessProfile', 'id', id);
		                            localVarPath = "/access-profiles/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API lists the Entitlements associated with a given Access Profile  A token with API, ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to invoke this API. In addition, a token with SOURCE_SUBADMIN authority must have access to the Source associated with the given Access Profile
		         * @summary List Access Profile\'s Entitlements
		         * @param {string} id ID of the containing Access Profile
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **name**: *eq, sw*  **attribute**: *eq, sw*  **value**: *eq, sw*  **created**: *gt, lt, ge, le*  **modified**: *gt, lt, ge, le*  **owner.id**: *eq, in*  **source.id**: *eq, in*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name, attribute, value, created, modified**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getAccessProfileEntitlements: function (id, limit, offset, count, filters, sorters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getAccessProfileEntitlements', 'id', id);
		                            localVarPath = "/access-profiles/{id}/entitlements"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns a list of Access Profiles.  A token with API, ORG_ADMIN, ROLE_ADMIN, ROLE_SUBADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		         * @summary List Access Profiles
		         * @param {string} [forSubadmin] If provided, filters the returned list according to what is visible to the indicated ROLE_SUBADMIN or SOURCE_SUBADMIN Identity. The value of the parameter is either an Identity ID, or the special value **me**, which is shorthand for the calling Identity\&#39;s ID.  A 400 Bad Request error is returned if the **for-subadmin** parameter is specified for an Identity that is not a subadmin.
		         * @param {number} [limit] Note that for this API the maximum value for limit is 50. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **name**: *eq, sw*  **created**: *gt, lt, ge, le*  **modified**: *gt, lt, ge, le*  **owner.id**: *eq, in*  **requestable**: *eq*  **source.id**: *eq, in*  Composite operators supported: *and, or*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name, created, modified**
		         * @param {string} [forSegmentIds] If present and not empty, additionally filters Access Profiles to those which are assigned to the Segment(s) with the specified IDs.  If segmentation is currently unavailable, specifying this parameter results in an error.
		         * @param {boolean} [includeUnsegmented] Whether or not the response list should contain unsegmented Access Profiles. If *for-segment-ids* is absent or empty, specifying *include-unsegmented* as false results in an error.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listAccessProfiles: function (forSubadmin, limit, offset, count, filters, sorters, forSegmentIds, includeUnsegmented, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/access-profiles";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (forSubadmin !== undefined) {
		                                localVarQueryParameter['for-subadmin'] = forSubadmin;
		                            }
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            if (forSegmentIds !== undefined) {
		                                localVarQueryParameter['for-segment-ids'] = forSegmentIds;
		                            }
		                            if (includeUnsegmented !== undefined) {
		                                localVarQueryParameter['include-unsegmented'] = includeUnsegmented;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API updates an existing Access Profile. The following fields are patchable:  **name**  **description**  **enabled**  **owner**  **requestable**  **accessRequestConfig**  **revokeRequestConfig**  **segments**  **entitlements**  **provisioningCriteria**  **source** (must be updated with entitlements belonging to new source in the same API call)  If you need to change the `source` of the access profile, you can do so only if you update the `entitlements` in the same API call.  The new entitlements can only come from the target source that you want to change to.  Look for the example \"Replace Source\" in the examples dropdown.  A token with API, ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API. In addition, a SOURCE_SUBADMIN may only use this API to patch Access Profiles which are associated with Sources they are able to administer. >  The maximum supported length for the description field is 2000 characters. Longer descriptions will be preserved for existing access profiles, however, any new access profiles as well as any updates to existing descriptions will be limited to 2000 characters.  > You can only add or replace **entitlements** that exist on the source that the access profile is attached to. You can use the **list entitlements** endpoint with the **filters** query parameter to get a list of available entitlements on the access profile\'s source.  >  Patching the value of the **requestable** field is only supported for customers enabled with the new Request Center. Otherwise, attempting to modify this field results in a 400 error.
		         * @summary Patch a specified Access Profile
		         * @param {string} id ID of the Access Profile to patch
		         * @param {Array<JsonPatchOperation>} jsonPatchOperation
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchAccessProfile: function (id, jsonPatchOperation, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('patchAccessProfile', 'id', id);
		                            // verify required parameter 'jsonPatchOperation' is not null or undefined
		                            (0, common_1.assertParamExists)('patchAccessProfile', 'jsonPatchOperation', jsonPatchOperation);
		                            localVarPath = "/access-profiles/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PATCH' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json-patch+json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(jsonPatchOperation, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.AccessProfilesApiAxiosParamCreator = AccessProfilesApiAxiosParamCreator;
		/**
		 * AccessProfilesApi - functional programming interface
		 * @export
		 */
		var AccessProfilesApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.AccessProfilesApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * This API creates an Access Profile. A token with API, ORG_ADMIN, ROLE_ADMIN, ROLE_SUBADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API. In addition, a token with only ROLE_SUBADMIN or SOURCE_SUBADMIN authority must be associated with the Access Profile\'s Source. The maximum supported length for the description field is 2000 characters. Longer descriptions will be preserved for existing access profiles, however, any new access profiles as well as any updates to existing descriptions will be limited to 2000 characters.
		         * @summary Create an Access Profile
		         * @param {AccessProfile} accessProfile
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createAccessProfile: function (accessProfile, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.createAccessProfile(accessProfile, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API deletes an existing Access Profile.  The Access Profile must not be in use, for example, Access Profile can not be deleted if they belong to an Application, Life Cycle State or a Role. If it is, a 400 error is returned.  A token with API, ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to invoke this API. In addition, a SOURCE_SUBADMIN token must be able to administer the Source associated with the Access Profile.
		         * @summary Delete the specified Access Profile
		         * @param {string} id ID of the Access Profile to delete
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteAccessProfile: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.deleteAccessProfile(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API initiates a bulk deletion of one or more Access Profiles.  By default, if any of the indicated Access Profiles are in use, no deletions will be performed and the **inUse** field of the response indicates the usages that must be removed first. If the request field **bestEffortOnly** is **true**, however, usages are reported in the **inUse** response field but all other indicated Access Profiles will be deleted.  A token with API, ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API. In addition, a SOURCE_SUBADMIN may only use this API to delete Access Profiles which are associated with Sources they are able to administer.
		         * @summary Delete Access Profile(s)
		         * @param {AccessProfileBulkDeleteRequest} accessProfileBulkDeleteRequest
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteAccessProfilesInBulk: function (accessProfileBulkDeleteRequest, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.deleteAccessProfilesInBulk(accessProfileBulkDeleteRequest, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns an Access Profile by its ID.  A token with API, ORG_ADMIN, ROLE_ADMIN, ROLE_SUBADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		         * @summary Get an Access Profile
		         * @param {string} id ID of the Access Profile
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getAccessProfile: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getAccessProfile(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API lists the Entitlements associated with a given Access Profile  A token with API, ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to invoke this API. In addition, a token with SOURCE_SUBADMIN authority must have access to the Source associated with the given Access Profile
		         * @summary List Access Profile\'s Entitlements
		         * @param {string} id ID of the containing Access Profile
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **name**: *eq, sw*  **attribute**: *eq, sw*  **value**: *eq, sw*  **created**: *gt, lt, ge, le*  **modified**: *gt, lt, ge, le*  **owner.id**: *eq, in*  **source.id**: *eq, in*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name, attribute, value, created, modified**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getAccessProfileEntitlements: function (id, limit, offset, count, filters, sorters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getAccessProfileEntitlements(id, limit, offset, count, filters, sorters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns a list of Access Profiles.  A token with API, ORG_ADMIN, ROLE_ADMIN, ROLE_SUBADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		         * @summary List Access Profiles
		         * @param {string} [forSubadmin] If provided, filters the returned list according to what is visible to the indicated ROLE_SUBADMIN or SOURCE_SUBADMIN Identity. The value of the parameter is either an Identity ID, or the special value **me**, which is shorthand for the calling Identity\&#39;s ID.  A 400 Bad Request error is returned if the **for-subadmin** parameter is specified for an Identity that is not a subadmin.
		         * @param {number} [limit] Note that for this API the maximum value for limit is 50. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **name**: *eq, sw*  **created**: *gt, lt, ge, le*  **modified**: *gt, lt, ge, le*  **owner.id**: *eq, in*  **requestable**: *eq*  **source.id**: *eq, in*  Composite operators supported: *and, or*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name, created, modified**
		         * @param {string} [forSegmentIds] If present and not empty, additionally filters Access Profiles to those which are assigned to the Segment(s) with the specified IDs.  If segmentation is currently unavailable, specifying this parameter results in an error.
		         * @param {boolean} [includeUnsegmented] Whether or not the response list should contain unsegmented Access Profiles. If *for-segment-ids* is absent or empty, specifying *include-unsegmented* as false results in an error.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listAccessProfiles: function (forSubadmin, limit, offset, count, filters, sorters, forSegmentIds, includeUnsegmented, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listAccessProfiles(forSubadmin, limit, offset, count, filters, sorters, forSegmentIds, includeUnsegmented, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API updates an existing Access Profile. The following fields are patchable:  **name**  **description**  **enabled**  **owner**  **requestable**  **accessRequestConfig**  **revokeRequestConfig**  **segments**  **entitlements**  **provisioningCriteria**  **source** (must be updated with entitlements belonging to new source in the same API call)  If you need to change the `source` of the access profile, you can do so only if you update the `entitlements` in the same API call.  The new entitlements can only come from the target source that you want to change to.  Look for the example \"Replace Source\" in the examples dropdown.  A token with API, ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API. In addition, a SOURCE_SUBADMIN may only use this API to patch Access Profiles which are associated with Sources they are able to administer. >  The maximum supported length for the description field is 2000 characters. Longer descriptions will be preserved for existing access profiles, however, any new access profiles as well as any updates to existing descriptions will be limited to 2000 characters.  > You can only add or replace **entitlements** that exist on the source that the access profile is attached to. You can use the **list entitlements** endpoint with the **filters** query parameter to get a list of available entitlements on the access profile\'s source.  >  Patching the value of the **requestable** field is only supported for customers enabled with the new Request Center. Otherwise, attempting to modify this field results in a 400 error.
		         * @summary Patch a specified Access Profile
		         * @param {string} id ID of the Access Profile to patch
		         * @param {Array<JsonPatchOperation>} jsonPatchOperation
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchAccessProfile: function (id, jsonPatchOperation, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.patchAccessProfile(id, jsonPatchOperation, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.AccessProfilesApiFp = AccessProfilesApiFp;
		/**
		 * AccessProfilesApi - factory interface
		 * @export
		 */
		var AccessProfilesApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.AccessProfilesApiFp)(configuration);
		    return {
		        /**
		         * This API creates an Access Profile. A token with API, ORG_ADMIN, ROLE_ADMIN, ROLE_SUBADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API. In addition, a token with only ROLE_SUBADMIN or SOURCE_SUBADMIN authority must be associated with the Access Profile\'s Source. The maximum supported length for the description field is 2000 characters. Longer descriptions will be preserved for existing access profiles, however, any new access profiles as well as any updates to existing descriptions will be limited to 2000 characters.
		         * @summary Create an Access Profile
		         * @param {AccessProfile} accessProfile
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createAccessProfile: function (accessProfile, axiosOptions) {
		            return localVarFp.createAccessProfile(accessProfile, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API deletes an existing Access Profile.  The Access Profile must not be in use, for example, Access Profile can not be deleted if they belong to an Application, Life Cycle State or a Role. If it is, a 400 error is returned.  A token with API, ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to invoke this API. In addition, a SOURCE_SUBADMIN token must be able to administer the Source associated with the Access Profile.
		         * @summary Delete the specified Access Profile
		         * @param {string} id ID of the Access Profile to delete
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteAccessProfile: function (id, axiosOptions) {
		            return localVarFp.deleteAccessProfile(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API initiates a bulk deletion of one or more Access Profiles.  By default, if any of the indicated Access Profiles are in use, no deletions will be performed and the **inUse** field of the response indicates the usages that must be removed first. If the request field **bestEffortOnly** is **true**, however, usages are reported in the **inUse** response field but all other indicated Access Profiles will be deleted.  A token with API, ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API. In addition, a SOURCE_SUBADMIN may only use this API to delete Access Profiles which are associated with Sources they are able to administer.
		         * @summary Delete Access Profile(s)
		         * @param {AccessProfileBulkDeleteRequest} accessProfileBulkDeleteRequest
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteAccessProfilesInBulk: function (accessProfileBulkDeleteRequest, axiosOptions) {
		            return localVarFp.deleteAccessProfilesInBulk(accessProfileBulkDeleteRequest, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API returns an Access Profile by its ID.  A token with API, ORG_ADMIN, ROLE_ADMIN, ROLE_SUBADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		         * @summary Get an Access Profile
		         * @param {string} id ID of the Access Profile
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getAccessProfile: function (id, axiosOptions) {
		            return localVarFp.getAccessProfile(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API lists the Entitlements associated with a given Access Profile  A token with API, ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to invoke this API. In addition, a token with SOURCE_SUBADMIN authority must have access to the Source associated with the given Access Profile
		         * @summary List Access Profile\'s Entitlements
		         * @param {string} id ID of the containing Access Profile
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **name**: *eq, sw*  **attribute**: *eq, sw*  **value**: *eq, sw*  **created**: *gt, lt, ge, le*  **modified**: *gt, lt, ge, le*  **owner.id**: *eq, in*  **source.id**: *eq, in*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name, attribute, value, created, modified**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getAccessProfileEntitlements: function (id, limit, offset, count, filters, sorters, axiosOptions) {
		            return localVarFp.getAccessProfileEntitlements(id, limit, offset, count, filters, sorters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API returns a list of Access Profiles.  A token with API, ORG_ADMIN, ROLE_ADMIN, ROLE_SUBADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		         * @summary List Access Profiles
		         * @param {string} [forSubadmin] If provided, filters the returned list according to what is visible to the indicated ROLE_SUBADMIN or SOURCE_SUBADMIN Identity. The value of the parameter is either an Identity ID, or the special value **me**, which is shorthand for the calling Identity\&#39;s ID.  A 400 Bad Request error is returned if the **for-subadmin** parameter is specified for an Identity that is not a subadmin.
		         * @param {number} [limit] Note that for this API the maximum value for limit is 50. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **name**: *eq, sw*  **created**: *gt, lt, ge, le*  **modified**: *gt, lt, ge, le*  **owner.id**: *eq, in*  **requestable**: *eq*  **source.id**: *eq, in*  Composite operators supported: *and, or*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name, created, modified**
		         * @param {string} [forSegmentIds] If present and not empty, additionally filters Access Profiles to those which are assigned to the Segment(s) with the specified IDs.  If segmentation is currently unavailable, specifying this parameter results in an error.
		         * @param {boolean} [includeUnsegmented] Whether or not the response list should contain unsegmented Access Profiles. If *for-segment-ids* is absent or empty, specifying *include-unsegmented* as false results in an error.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listAccessProfiles: function (forSubadmin, limit, offset, count, filters, sorters, forSegmentIds, includeUnsegmented, axiosOptions) {
		            return localVarFp.listAccessProfiles(forSubadmin, limit, offset, count, filters, sorters, forSegmentIds, includeUnsegmented, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API updates an existing Access Profile. The following fields are patchable:  **name**  **description**  **enabled**  **owner**  **requestable**  **accessRequestConfig**  **revokeRequestConfig**  **segments**  **entitlements**  **provisioningCriteria**  **source** (must be updated with entitlements belonging to new source in the same API call)  If you need to change the `source` of the access profile, you can do so only if you update the `entitlements` in the same API call.  The new entitlements can only come from the target source that you want to change to.  Look for the example \"Replace Source\" in the examples dropdown.  A token with API, ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API. In addition, a SOURCE_SUBADMIN may only use this API to patch Access Profiles which are associated with Sources they are able to administer. >  The maximum supported length for the description field is 2000 characters. Longer descriptions will be preserved for existing access profiles, however, any new access profiles as well as any updates to existing descriptions will be limited to 2000 characters.  > You can only add or replace **entitlements** that exist on the source that the access profile is attached to. You can use the **list entitlements** endpoint with the **filters** query parameter to get a list of available entitlements on the access profile\'s source.  >  Patching the value of the **requestable** field is only supported for customers enabled with the new Request Center. Otherwise, attempting to modify this field results in a 400 error.
		         * @summary Patch a specified Access Profile
		         * @param {string} id ID of the Access Profile to patch
		         * @param {Array<JsonPatchOperation>} jsonPatchOperation
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchAccessProfile: function (id, jsonPatchOperation, axiosOptions) {
		            return localVarFp.patchAccessProfile(id, jsonPatchOperation, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.AccessProfilesApiFactory = AccessProfilesApiFactory;
		/**
		 * AccessProfilesApi - object-oriented interface
		 * @export
		 * @class AccessProfilesApi
		 * @extends {BaseAPI}
		 */
		var AccessProfilesApi = /** @class */ (function (_super) {
		    __extends(AccessProfilesApi, _super);
		    function AccessProfilesApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * This API creates an Access Profile. A token with API, ORG_ADMIN, ROLE_ADMIN, ROLE_SUBADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API. In addition, a token with only ROLE_SUBADMIN or SOURCE_SUBADMIN authority must be associated with the Access Profile\'s Source. The maximum supported length for the description field is 2000 characters. Longer descriptions will be preserved for existing access profiles, however, any new access profiles as well as any updates to existing descriptions will be limited to 2000 characters.
		     * @summary Create an Access Profile
		     * @param {AccessProfilesApiCreateAccessProfileRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof AccessProfilesApi
		     */
		    AccessProfilesApi.prototype.createAccessProfile = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.AccessProfilesApiFp)(this.configuration).createAccessProfile(requestParameters.accessProfile, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API deletes an existing Access Profile.  The Access Profile must not be in use, for example, Access Profile can not be deleted if they belong to an Application, Life Cycle State or a Role. If it is, a 400 error is returned.  A token with API, ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to invoke this API. In addition, a SOURCE_SUBADMIN token must be able to administer the Source associated with the Access Profile.
		     * @summary Delete the specified Access Profile
		     * @param {AccessProfilesApiDeleteAccessProfileRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof AccessProfilesApi
		     */
		    AccessProfilesApi.prototype.deleteAccessProfile = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.AccessProfilesApiFp)(this.configuration).deleteAccessProfile(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API initiates a bulk deletion of one or more Access Profiles.  By default, if any of the indicated Access Profiles are in use, no deletions will be performed and the **inUse** field of the response indicates the usages that must be removed first. If the request field **bestEffortOnly** is **true**, however, usages are reported in the **inUse** response field but all other indicated Access Profiles will be deleted.  A token with API, ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API. In addition, a SOURCE_SUBADMIN may only use this API to delete Access Profiles which are associated with Sources they are able to administer.
		     * @summary Delete Access Profile(s)
		     * @param {AccessProfilesApiDeleteAccessProfilesInBulkRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof AccessProfilesApi
		     */
		    AccessProfilesApi.prototype.deleteAccessProfilesInBulk = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.AccessProfilesApiFp)(this.configuration).deleteAccessProfilesInBulk(requestParameters.accessProfileBulkDeleteRequest, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API returns an Access Profile by its ID.  A token with API, ORG_ADMIN, ROLE_ADMIN, ROLE_SUBADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		     * @summary Get an Access Profile
		     * @param {AccessProfilesApiGetAccessProfileRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof AccessProfilesApi
		     */
		    AccessProfilesApi.prototype.getAccessProfile = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.AccessProfilesApiFp)(this.configuration).getAccessProfile(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API lists the Entitlements associated with a given Access Profile  A token with API, ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to invoke this API. In addition, a token with SOURCE_SUBADMIN authority must have access to the Source associated with the given Access Profile
		     * @summary List Access Profile\'s Entitlements
		     * @param {AccessProfilesApiGetAccessProfileEntitlementsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof AccessProfilesApi
		     */
		    AccessProfilesApi.prototype.getAccessProfileEntitlements = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.AccessProfilesApiFp)(this.configuration).getAccessProfileEntitlements(requestParameters.id, requestParameters.limit, requestParameters.offset, requestParameters.count, requestParameters.filters, requestParameters.sorters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API returns a list of Access Profiles.  A token with API, ORG_ADMIN, ROLE_ADMIN, ROLE_SUBADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		     * @summary List Access Profiles
		     * @param {AccessProfilesApiListAccessProfilesRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof AccessProfilesApi
		     */
		    AccessProfilesApi.prototype.listAccessProfiles = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.AccessProfilesApiFp)(this.configuration).listAccessProfiles(requestParameters.forSubadmin, requestParameters.limit, requestParameters.offset, requestParameters.count, requestParameters.filters, requestParameters.sorters, requestParameters.forSegmentIds, requestParameters.includeUnsegmented, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API updates an existing Access Profile. The following fields are patchable:  **name**  **description**  **enabled**  **owner**  **requestable**  **accessRequestConfig**  **revokeRequestConfig**  **segments**  **entitlements**  **provisioningCriteria**  **source** (must be updated with entitlements belonging to new source in the same API call)  If you need to change the `source` of the access profile, you can do so only if you update the `entitlements` in the same API call.  The new entitlements can only come from the target source that you want to change to.  Look for the example \"Replace Source\" in the examples dropdown.  A token with API, ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API. In addition, a SOURCE_SUBADMIN may only use this API to patch Access Profiles which are associated with Sources they are able to administer. >  The maximum supported length for the description field is 2000 characters. Longer descriptions will be preserved for existing access profiles, however, any new access profiles as well as any updates to existing descriptions will be limited to 2000 characters.  > You can only add or replace **entitlements** that exist on the source that the access profile is attached to. You can use the **list entitlements** endpoint with the **filters** query parameter to get a list of available entitlements on the access profile\'s source.  >  Patching the value of the **requestable** field is only supported for customers enabled with the new Request Center. Otherwise, attempting to modify this field results in a 400 error.
		     * @summary Patch a specified Access Profile
		     * @param {AccessProfilesApiPatchAccessProfileRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof AccessProfilesApi
		     */
		    AccessProfilesApi.prototype.patchAccessProfile = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.AccessProfilesApiFp)(this.configuration).patchAccessProfile(requestParameters.id, requestParameters.jsonPatchOperation, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return AccessProfilesApi;
		}(base_1.BaseAPI));
		exports.AccessProfilesApi = AccessProfilesApi;
		/**
		 * AccessRequestApprovalsApi - axios parameter creator
		 * @export
		 */
		var AccessRequestApprovalsApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * This endpoint approves an access request approval. Only the owner of the approval and ORG_ADMIN users are allowed to perform this action.
		         * @summary Approves an access request approval.
		         * @param {string} approvalId The id of the approval.
		         * @param {CommentDto} [commentDto] Reviewer\&#39;s comment.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        approveAccessRequest: function (approvalId, commentDto, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'approvalId' is not null or undefined
		                            (0, common_1.assertParamExists)('approveAccessRequest', 'approvalId', approvalId);
		                            localVarPath = "/access-request-approvals/{approvalId}/approve"
		                                .replace("{".concat("approvalId", "}"), encodeURIComponent(String(approvalId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(commentDto, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This endpoint forwards an access request approval to a new owner. Only the owner of the approval and ORG_ADMIN users are allowed to perform this action.
		         * @summary Forwards an access request approval.
		         * @param {string} approvalId The id of the approval.
		         * @param {ForwardApprovalDto} forwardApprovalDto Information about the forwarded approval.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        forwardAccessRequest: function (approvalId, forwardApprovalDto, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'approvalId' is not null or undefined
		                            (0, common_1.assertParamExists)('forwardAccessRequest', 'approvalId', approvalId);
		                            // verify required parameter 'forwardApprovalDto' is not null or undefined
		                            (0, common_1.assertParamExists)('forwardAccessRequest', 'forwardApprovalDto', forwardApprovalDto);
		                            localVarPath = "/access-request-approvals/{approvalId}/forward"
		                                .replace("{".concat("approvalId", "}"), encodeURIComponent(String(approvalId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(forwardApprovalDto, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This endpoint returns the number of pending, approved and rejected access requests approvals. See \"owner-id\" query parameter below for authorization info.
		         * @summary Get the number of access-requests-approvals
		         * @param {string} [ownerId] The id of the owner or approver identity of the approvals. If present, the value returns approval summary for the specified identity.    * ORG_ADMIN users can call this with any identity ID value.    * ORG_ADMIN user can also fetch all the approvals in the org, when owner-id is not used.    * Non ORG_ADMIN users can only specify *me* or pass their own identity ID value.
		         * @param {string} [fromDate] From date is the date and time from which the results will be shown. It should be in a valid ISO-8601 format
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getAccessRequestApprovalSummary: function (ownerId, fromDate, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/access-request-approvals/approval-summary";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (ownerId !== undefined) {
		                                localVarQueryParameter['owner-id'] = ownerId;
		                            }
		                            if (fromDate !== undefined) {
		                                localVarQueryParameter['from-date'] = fromDate;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This endpoint returns list of completed approvals. See *owner-id* query parameter below for authorization info.
		         * @summary Completed Access Request Approvals List
		         * @param {string} [ownerId] If present, the value returns only completed approvals for the specified identity.    * ORG_ADMIN users can call this with any identity ID value.    * ORG_ADMIN users can also fetch all the approvals in the org, when owner-id is not used.    * Non-ORG_ADMIN users can only specify *me* or pass their own identity ID value.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in, ge, gt, le, lt, ne, isnull, sw*  **requestedFor.id**: *eq, in, ge, gt, le, lt, ne, isnull, sw*  **modified**: *gt, lt, ge, le, eq, in, ne, sw*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **created, modified**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listCompletedApprovals: function (ownerId, limit, offset, count, filters, sorters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/access-request-approvals/completed";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (ownerId !== undefined) {
		                                localVarQueryParameter['owner-id'] = ownerId;
		                            }
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This endpoint returns a list of pending approvals. See \"owner-id\" query parameter below for authorization info.
		         * @summary Pending Access Request Approvals List
		         * @param {string} [ownerId] If present, the value returns only pending approvals for the specified identity.    * ORG_ADMIN users can call this with any identity ID value.    * ORG_ADMIN users can also fetch all the approvals in the org, when owner-id is not used.    * Non-ORG_ADMIN users can only specify *me* or pass their own identity ID value.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **requestedFor.id**: *eq, in*  **modified**: *gt, lt, ge, le, eq, in*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **created, modified**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listPendingApprovals: function (ownerId, limit, offset, count, filters, sorters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/access-request-approvals/pending";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (ownerId !== undefined) {
		                                localVarQueryParameter['owner-id'] = ownerId;
		                            }
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This endpoint rejects an access request approval. Only the owner of the approval and admin users are allowed to perform this action.
		         * @summary Rejects an access request approval.
		         * @param {string} approvalId The id of the approval.
		         * @param {CommentDto} [commentDto] Reviewer\&#39;s comment.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        rejectAccessRequest: function (approvalId, commentDto, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'approvalId' is not null or undefined
		                            (0, common_1.assertParamExists)('rejectAccessRequest', 'approvalId', approvalId);
		                            localVarPath = "/access-request-approvals/{approvalId}/reject"
		                                .replace("{".concat("approvalId", "}"), encodeURIComponent(String(approvalId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(commentDto, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.AccessRequestApprovalsApiAxiosParamCreator = AccessRequestApprovalsApiAxiosParamCreator;
		/**
		 * AccessRequestApprovalsApi - functional programming interface
		 * @export
		 */
		var AccessRequestApprovalsApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.AccessRequestApprovalsApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * This endpoint approves an access request approval. Only the owner of the approval and ORG_ADMIN users are allowed to perform this action.
		         * @summary Approves an access request approval.
		         * @param {string} approvalId The id of the approval.
		         * @param {CommentDto} [commentDto] Reviewer\&#39;s comment.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        approveAccessRequest: function (approvalId, commentDto, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.approveAccessRequest(approvalId, commentDto, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This endpoint forwards an access request approval to a new owner. Only the owner of the approval and ORG_ADMIN users are allowed to perform this action.
		         * @summary Forwards an access request approval.
		         * @param {string} approvalId The id of the approval.
		         * @param {ForwardApprovalDto} forwardApprovalDto Information about the forwarded approval.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        forwardAccessRequest: function (approvalId, forwardApprovalDto, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.forwardAccessRequest(approvalId, forwardApprovalDto, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This endpoint returns the number of pending, approved and rejected access requests approvals. See \"owner-id\" query parameter below for authorization info.
		         * @summary Get the number of access-requests-approvals
		         * @param {string} [ownerId] The id of the owner or approver identity of the approvals. If present, the value returns approval summary for the specified identity.    * ORG_ADMIN users can call this with any identity ID value.    * ORG_ADMIN user can also fetch all the approvals in the org, when owner-id is not used.    * Non ORG_ADMIN users can only specify *me* or pass their own identity ID value.
		         * @param {string} [fromDate] From date is the date and time from which the results will be shown. It should be in a valid ISO-8601 format
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getAccessRequestApprovalSummary: function (ownerId, fromDate, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getAccessRequestApprovalSummary(ownerId, fromDate, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This endpoint returns list of completed approvals. See *owner-id* query parameter below for authorization info.
		         * @summary Completed Access Request Approvals List
		         * @param {string} [ownerId] If present, the value returns only completed approvals for the specified identity.    * ORG_ADMIN users can call this with any identity ID value.    * ORG_ADMIN users can also fetch all the approvals in the org, when owner-id is not used.    * Non-ORG_ADMIN users can only specify *me* or pass their own identity ID value.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in, ge, gt, le, lt, ne, isnull, sw*  **requestedFor.id**: *eq, in, ge, gt, le, lt, ne, isnull, sw*  **modified**: *gt, lt, ge, le, eq, in, ne, sw*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **created, modified**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listCompletedApprovals: function (ownerId, limit, offset, count, filters, sorters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listCompletedApprovals(ownerId, limit, offset, count, filters, sorters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This endpoint returns a list of pending approvals. See \"owner-id\" query parameter below for authorization info.
		         * @summary Pending Access Request Approvals List
		         * @param {string} [ownerId] If present, the value returns only pending approvals for the specified identity.    * ORG_ADMIN users can call this with any identity ID value.    * ORG_ADMIN users can also fetch all the approvals in the org, when owner-id is not used.    * Non-ORG_ADMIN users can only specify *me* or pass their own identity ID value.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **requestedFor.id**: *eq, in*  **modified**: *gt, lt, ge, le, eq, in*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **created, modified**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listPendingApprovals: function (ownerId, limit, offset, count, filters, sorters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listPendingApprovals(ownerId, limit, offset, count, filters, sorters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This endpoint rejects an access request approval. Only the owner of the approval and admin users are allowed to perform this action.
		         * @summary Rejects an access request approval.
		         * @param {string} approvalId The id of the approval.
		         * @param {CommentDto} [commentDto] Reviewer\&#39;s comment.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        rejectAccessRequest: function (approvalId, commentDto, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.rejectAccessRequest(approvalId, commentDto, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.AccessRequestApprovalsApiFp = AccessRequestApprovalsApiFp;
		/**
		 * AccessRequestApprovalsApi - factory interface
		 * @export
		 */
		var AccessRequestApprovalsApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.AccessRequestApprovalsApiFp)(configuration);
		    return {
		        /**
		         * This endpoint approves an access request approval. Only the owner of the approval and ORG_ADMIN users are allowed to perform this action.
		         * @summary Approves an access request approval.
		         * @param {string} approvalId The id of the approval.
		         * @param {CommentDto} [commentDto] Reviewer\&#39;s comment.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        approveAccessRequest: function (approvalId, commentDto, axiosOptions) {
		            return localVarFp.approveAccessRequest(approvalId, commentDto, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This endpoint forwards an access request approval to a new owner. Only the owner of the approval and ORG_ADMIN users are allowed to perform this action.
		         * @summary Forwards an access request approval.
		         * @param {string} approvalId The id of the approval.
		         * @param {ForwardApprovalDto} forwardApprovalDto Information about the forwarded approval.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        forwardAccessRequest: function (approvalId, forwardApprovalDto, axiosOptions) {
		            return localVarFp.forwardAccessRequest(approvalId, forwardApprovalDto, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This endpoint returns the number of pending, approved and rejected access requests approvals. See \"owner-id\" query parameter below for authorization info.
		         * @summary Get the number of access-requests-approvals
		         * @param {string} [ownerId] The id of the owner or approver identity of the approvals. If present, the value returns approval summary for the specified identity.    * ORG_ADMIN users can call this with any identity ID value.    * ORG_ADMIN user can also fetch all the approvals in the org, when owner-id is not used.    * Non ORG_ADMIN users can only specify *me* or pass their own identity ID value.
		         * @param {string} [fromDate] From date is the date and time from which the results will be shown. It should be in a valid ISO-8601 format
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getAccessRequestApprovalSummary: function (ownerId, fromDate, axiosOptions) {
		            return localVarFp.getAccessRequestApprovalSummary(ownerId, fromDate, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This endpoint returns list of completed approvals. See *owner-id* query parameter below for authorization info.
		         * @summary Completed Access Request Approvals List
		         * @param {string} [ownerId] If present, the value returns only completed approvals for the specified identity.    * ORG_ADMIN users can call this with any identity ID value.    * ORG_ADMIN users can also fetch all the approvals in the org, when owner-id is not used.    * Non-ORG_ADMIN users can only specify *me* or pass their own identity ID value.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in, ge, gt, le, lt, ne, isnull, sw*  **requestedFor.id**: *eq, in, ge, gt, le, lt, ne, isnull, sw*  **modified**: *gt, lt, ge, le, eq, in, ne, sw*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **created, modified**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listCompletedApprovals: function (ownerId, limit, offset, count, filters, sorters, axiosOptions) {
		            return localVarFp.listCompletedApprovals(ownerId, limit, offset, count, filters, sorters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This endpoint returns a list of pending approvals. See \"owner-id\" query parameter below for authorization info.
		         * @summary Pending Access Request Approvals List
		         * @param {string} [ownerId] If present, the value returns only pending approvals for the specified identity.    * ORG_ADMIN users can call this with any identity ID value.    * ORG_ADMIN users can also fetch all the approvals in the org, when owner-id is not used.    * Non-ORG_ADMIN users can only specify *me* or pass their own identity ID value.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **requestedFor.id**: *eq, in*  **modified**: *gt, lt, ge, le, eq, in*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **created, modified**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listPendingApprovals: function (ownerId, limit, offset, count, filters, sorters, axiosOptions) {
		            return localVarFp.listPendingApprovals(ownerId, limit, offset, count, filters, sorters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This endpoint rejects an access request approval. Only the owner of the approval and admin users are allowed to perform this action.
		         * @summary Rejects an access request approval.
		         * @param {string} approvalId The id of the approval.
		         * @param {CommentDto} [commentDto] Reviewer\&#39;s comment.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        rejectAccessRequest: function (approvalId, commentDto, axiosOptions) {
		            return localVarFp.rejectAccessRequest(approvalId, commentDto, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.AccessRequestApprovalsApiFactory = AccessRequestApprovalsApiFactory;
		/**
		 * AccessRequestApprovalsApi - object-oriented interface
		 * @export
		 * @class AccessRequestApprovalsApi
		 * @extends {BaseAPI}
		 */
		var AccessRequestApprovalsApi = /** @class */ (function (_super) {
		    __extends(AccessRequestApprovalsApi, _super);
		    function AccessRequestApprovalsApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * This endpoint approves an access request approval. Only the owner of the approval and ORG_ADMIN users are allowed to perform this action.
		     * @summary Approves an access request approval.
		     * @param {AccessRequestApprovalsApiApproveAccessRequestRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof AccessRequestApprovalsApi
		     */
		    AccessRequestApprovalsApi.prototype.approveAccessRequest = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.AccessRequestApprovalsApiFp)(this.configuration).approveAccessRequest(requestParameters.approvalId, requestParameters.commentDto, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This endpoint forwards an access request approval to a new owner. Only the owner of the approval and ORG_ADMIN users are allowed to perform this action.
		     * @summary Forwards an access request approval.
		     * @param {AccessRequestApprovalsApiForwardAccessRequestRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof AccessRequestApprovalsApi
		     */
		    AccessRequestApprovalsApi.prototype.forwardAccessRequest = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.AccessRequestApprovalsApiFp)(this.configuration).forwardAccessRequest(requestParameters.approvalId, requestParameters.forwardApprovalDto, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This endpoint returns the number of pending, approved and rejected access requests approvals. See \"owner-id\" query parameter below for authorization info.
		     * @summary Get the number of access-requests-approvals
		     * @param {AccessRequestApprovalsApiGetAccessRequestApprovalSummaryRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof AccessRequestApprovalsApi
		     */
		    AccessRequestApprovalsApi.prototype.getAccessRequestApprovalSummary = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.AccessRequestApprovalsApiFp)(this.configuration).getAccessRequestApprovalSummary(requestParameters.ownerId, requestParameters.fromDate, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This endpoint returns list of completed approvals. See *owner-id* query parameter below for authorization info.
		     * @summary Completed Access Request Approvals List
		     * @param {AccessRequestApprovalsApiListCompletedApprovalsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof AccessRequestApprovalsApi
		     */
		    AccessRequestApprovalsApi.prototype.listCompletedApprovals = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.AccessRequestApprovalsApiFp)(this.configuration).listCompletedApprovals(requestParameters.ownerId, requestParameters.limit, requestParameters.offset, requestParameters.count, requestParameters.filters, requestParameters.sorters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This endpoint returns a list of pending approvals. See \"owner-id\" query parameter below for authorization info.
		     * @summary Pending Access Request Approvals List
		     * @param {AccessRequestApprovalsApiListPendingApprovalsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof AccessRequestApprovalsApi
		     */
		    AccessRequestApprovalsApi.prototype.listPendingApprovals = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.AccessRequestApprovalsApiFp)(this.configuration).listPendingApprovals(requestParameters.ownerId, requestParameters.limit, requestParameters.offset, requestParameters.count, requestParameters.filters, requestParameters.sorters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This endpoint rejects an access request approval. Only the owner of the approval and admin users are allowed to perform this action.
		     * @summary Rejects an access request approval.
		     * @param {AccessRequestApprovalsApiRejectAccessRequestRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof AccessRequestApprovalsApi
		     */
		    AccessRequestApprovalsApi.prototype.rejectAccessRequest = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.AccessRequestApprovalsApiFp)(this.configuration).rejectAccessRequest(requestParameters.approvalId, requestParameters.commentDto, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return AccessRequestApprovalsApi;
		}(base_1.BaseAPI));
		exports.AccessRequestApprovalsApi = AccessRequestApprovalsApi;
		/**
		 * AccessRequestsApi - axios parameter creator
		 * @export
		 */
		var AccessRequestsApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * This API endpoint cancels a pending access request. An access request can be cancelled only if it has not passed the approval step. Any token with ORG_ADMIN authority or token of the user who originally requested the access request is required to cancel it.
		         * @summary Cancel Access Request
		         * @param {CancelAccessRequest} cancelAccessRequest
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        cancelAccessRequest: function (cancelAccessRequest, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'cancelAccessRequest' is not null or undefined
		                            (0, common_1.assertParamExists)('cancelAccessRequest', 'cancelAccessRequest', cancelAccessRequest);
		                            localVarPath = "/access-requests/cancel";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(cancelAccessRequest, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This submits the access request into IdentityNow, where it will follow any IdentityNow approval processes.  Access requests are processed asynchronously by IdentityNow.  A success response from this endpoint means the request has been submitted to IDN and is queued for processing.  Because this endpoint is asynchronous, it will not return an error if you submit duplicate access requests in quick succession, or you submit an access request for access that is already in progress, approved, or rejected. It is best practice to check for any existing access requests that reference the same access items before submitting a new access request.  This can be accomplished by using the [access request status](https://developer.sailpoint.com/idn/api/v3/list-access-request-status) or the [pending access request approvals](https://developer.sailpoint.com/idn/api/v3/list-pending-approvals) endpoints.  You can also use the [search API](https://developer.sailpoint.com/idn/api/v3/search) to check the existing access items that an identity has before submitting an access request to ensure you are not requesting access that is already granted.  There are two types of access request:  __GRANT_ACCESS__ * Can be requested for multiple identities in a single request. * Supports self request and request on behalf of other users. Refer to the [Get Access Request Configuration](https://developer.sailpoint.com/idn/api/v3/get-access-request-config) endpoint for request configuration options.   * Allows any authenticated token (except API) to call this endpoint to request to grant access to themselves. Depending on the configuration, a user can request access for others. * Roles, access profiles and entitlements can be requested. * While requesting entitlements, maximum of 25 entitlements and 10 recipients are allowed in a request.   __REVOKE_ACCESS__ * Can only be requested for a single identity at a time. * You cannot use an access request to revoke access from an identity if that access has been granted by role membership or by birthright provisioning.  * Does not support self request. Only manager can request to revoke access for their directly managed employees. * If a `removeDate` is specified, then the access will be removed on that date and time only for roles and access profiles. Entitlements are currently unsupported for `removeDate`. * Roles, access profiles, and entitlements can be requested for revocation. * Revoke requests for entitlements are limited to 1 entitlement per access request currently. * [Roles, Access Profiles] You can specify a `removeDate` if the access doesn\'t already have a sunset date. The `removeDate` must be a future date, in the UTC timezone.  * Allows a manager to request to revoke access for direct employees. A token with ORG_ADMIN authority can also request to revoke access from anyone.  >**Note:** There is no indication to the approver in the IdentityNow UI that the approval request is for a revoke action. Take this into consideration when calling this API.  A token with API authority cannot be used to call this endpoint.
		         * @summary Submit an Access Request
		         * @param {AccessRequest} accessRequest
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createAccessRequest: function (accessRequest, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'accessRequest' is not null or undefined
		                            (0, common_1.assertParamExists)('createAccessRequest', 'accessRequest', accessRequest);
		                            localVarPath = "/access-requests";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(accessRequest, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This endpoint returns the current access-request configuration.
		         * @summary Get Access Request Configuration
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getAccessRequestConfig: function (axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/access-request-config";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * The Access Request Status API returns a list of access request statuses based on the specified query parameters. Any token with any authority can request their own status. A token with ORG_ADMIN authority is required to call this API to get a list of statuses for other users.
		         * @summary Access Request Status
		         * @param {string} [requestedFor] Filter the results by the identity for which the requests were made. *me* indicates the current user. Mutually exclusive with *regarding-identity*.
		         * @param {string} [requestedBy] Filter the results by the identity that made the requests. *me* indicates the current user. Mutually exclusive with *regarding-identity*.
		         * @param {string} [regardingIdentity] Filter the results by the specified identity which is either the requester or target of the requests. *me* indicates the current user. Mutually exclusive with *requested-for* and *requested-by*.
		         * @param {string} [assignedTo] Filter the results by the specified identity which is the owner of the Identity Request Work Item. *me* indicates the current user.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.
		         * @param {number} [limit] Max number of results to return.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. Defaults to 0 if not specified.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **accountActivityItemId**: *eq, in, ge, gt, le, lt, ne, isnull, sw*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **created, modified, accountActivityItemId, name**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listAccessRequestStatus: function (requestedFor, requestedBy, regardingIdentity, assignedTo, count, limit, offset, filters, sorters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/access-request-status";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (requestedFor !== undefined) {
		                                localVarQueryParameter['requested-for'] = requestedFor;
		                            }
		                            if (requestedBy !== undefined) {
		                                localVarQueryParameter['requested-by'] = requestedBy;
		                            }
		                            if (regardingIdentity !== undefined) {
		                                localVarQueryParameter['regarding-identity'] = regardingIdentity;
		                            }
		                            if (assignedTo !== undefined) {
		                                localVarQueryParameter['assigned-to'] = assignedTo;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This endpoint replaces the current access-request configuration. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Update Access Request Configuration
		         * @param {AccessRequestConfig} accessRequestConfig
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        setAccessRequestConfig: function (accessRequestConfig, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'accessRequestConfig' is not null or undefined
		                            (0, common_1.assertParamExists)('setAccessRequestConfig', 'accessRequestConfig', accessRequestConfig);
		                            localVarPath = "/access-request-config";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PUT' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(accessRequestConfig, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.AccessRequestsApiAxiosParamCreator = AccessRequestsApiAxiosParamCreator;
		/**
		 * AccessRequestsApi - functional programming interface
		 * @export
		 */
		var AccessRequestsApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.AccessRequestsApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * This API endpoint cancels a pending access request. An access request can be cancelled only if it has not passed the approval step. Any token with ORG_ADMIN authority or token of the user who originally requested the access request is required to cancel it.
		         * @summary Cancel Access Request
		         * @param {CancelAccessRequest} cancelAccessRequest
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        cancelAccessRequest: function (cancelAccessRequest, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.cancelAccessRequest(cancelAccessRequest, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This submits the access request into IdentityNow, where it will follow any IdentityNow approval processes.  Access requests are processed asynchronously by IdentityNow.  A success response from this endpoint means the request has been submitted to IDN and is queued for processing.  Because this endpoint is asynchronous, it will not return an error if you submit duplicate access requests in quick succession, or you submit an access request for access that is already in progress, approved, or rejected. It is best practice to check for any existing access requests that reference the same access items before submitting a new access request.  This can be accomplished by using the [access request status](https://developer.sailpoint.com/idn/api/v3/list-access-request-status) or the [pending access request approvals](https://developer.sailpoint.com/idn/api/v3/list-pending-approvals) endpoints.  You can also use the [search API](https://developer.sailpoint.com/idn/api/v3/search) to check the existing access items that an identity has before submitting an access request to ensure you are not requesting access that is already granted.  There are two types of access request:  __GRANT_ACCESS__ * Can be requested for multiple identities in a single request. * Supports self request and request on behalf of other users. Refer to the [Get Access Request Configuration](https://developer.sailpoint.com/idn/api/v3/get-access-request-config) endpoint for request configuration options.   * Allows any authenticated token (except API) to call this endpoint to request to grant access to themselves. Depending on the configuration, a user can request access for others. * Roles, access profiles and entitlements can be requested. * While requesting entitlements, maximum of 25 entitlements and 10 recipients are allowed in a request.   __REVOKE_ACCESS__ * Can only be requested for a single identity at a time. * You cannot use an access request to revoke access from an identity if that access has been granted by role membership or by birthright provisioning.  * Does not support self request. Only manager can request to revoke access for their directly managed employees. * If a `removeDate` is specified, then the access will be removed on that date and time only for roles and access profiles. Entitlements are currently unsupported for `removeDate`. * Roles, access profiles, and entitlements can be requested for revocation. * Revoke requests for entitlements are limited to 1 entitlement per access request currently. * [Roles, Access Profiles] You can specify a `removeDate` if the access doesn\'t already have a sunset date. The `removeDate` must be a future date, in the UTC timezone.  * Allows a manager to request to revoke access for direct employees. A token with ORG_ADMIN authority can also request to revoke access from anyone.  >**Note:** There is no indication to the approver in the IdentityNow UI that the approval request is for a revoke action. Take this into consideration when calling this API.  A token with API authority cannot be used to call this endpoint.
		         * @summary Submit an Access Request
		         * @param {AccessRequest} accessRequest
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createAccessRequest: function (accessRequest, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.createAccessRequest(accessRequest, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This endpoint returns the current access-request configuration.
		         * @summary Get Access Request Configuration
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getAccessRequestConfig: function (axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getAccessRequestConfig(axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * The Access Request Status API returns a list of access request statuses based on the specified query parameters. Any token with any authority can request their own status. A token with ORG_ADMIN authority is required to call this API to get a list of statuses for other users.
		         * @summary Access Request Status
		         * @param {string} [requestedFor] Filter the results by the identity for which the requests were made. *me* indicates the current user. Mutually exclusive with *regarding-identity*.
		         * @param {string} [requestedBy] Filter the results by the identity that made the requests. *me* indicates the current user. Mutually exclusive with *regarding-identity*.
		         * @param {string} [regardingIdentity] Filter the results by the specified identity which is either the requester or target of the requests. *me* indicates the current user. Mutually exclusive with *requested-for* and *requested-by*.
		         * @param {string} [assignedTo] Filter the results by the specified identity which is the owner of the Identity Request Work Item. *me* indicates the current user.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.
		         * @param {number} [limit] Max number of results to return.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. Defaults to 0 if not specified.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **accountActivityItemId**: *eq, in, ge, gt, le, lt, ne, isnull, sw*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **created, modified, accountActivityItemId, name**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listAccessRequestStatus: function (requestedFor, requestedBy, regardingIdentity, assignedTo, count, limit, offset, filters, sorters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listAccessRequestStatus(requestedFor, requestedBy, regardingIdentity, assignedTo, count, limit, offset, filters, sorters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This endpoint replaces the current access-request configuration. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Update Access Request Configuration
		         * @param {AccessRequestConfig} accessRequestConfig
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        setAccessRequestConfig: function (accessRequestConfig, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.setAccessRequestConfig(accessRequestConfig, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.AccessRequestsApiFp = AccessRequestsApiFp;
		/**
		 * AccessRequestsApi - factory interface
		 * @export
		 */
		var AccessRequestsApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.AccessRequestsApiFp)(configuration);
		    return {
		        /**
		         * This API endpoint cancels a pending access request. An access request can be cancelled only if it has not passed the approval step. Any token with ORG_ADMIN authority or token of the user who originally requested the access request is required to cancel it.
		         * @summary Cancel Access Request
		         * @param {CancelAccessRequest} cancelAccessRequest
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        cancelAccessRequest: function (cancelAccessRequest, axiosOptions) {
		            return localVarFp.cancelAccessRequest(cancelAccessRequest, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This submits the access request into IdentityNow, where it will follow any IdentityNow approval processes.  Access requests are processed asynchronously by IdentityNow.  A success response from this endpoint means the request has been submitted to IDN and is queued for processing.  Because this endpoint is asynchronous, it will not return an error if you submit duplicate access requests in quick succession, or you submit an access request for access that is already in progress, approved, or rejected. It is best practice to check for any existing access requests that reference the same access items before submitting a new access request.  This can be accomplished by using the [access request status](https://developer.sailpoint.com/idn/api/v3/list-access-request-status) or the [pending access request approvals](https://developer.sailpoint.com/idn/api/v3/list-pending-approvals) endpoints.  You can also use the [search API](https://developer.sailpoint.com/idn/api/v3/search) to check the existing access items that an identity has before submitting an access request to ensure you are not requesting access that is already granted.  There are two types of access request:  __GRANT_ACCESS__ * Can be requested for multiple identities in a single request. * Supports self request and request on behalf of other users. Refer to the [Get Access Request Configuration](https://developer.sailpoint.com/idn/api/v3/get-access-request-config) endpoint for request configuration options.   * Allows any authenticated token (except API) to call this endpoint to request to grant access to themselves. Depending on the configuration, a user can request access for others. * Roles, access profiles and entitlements can be requested. * While requesting entitlements, maximum of 25 entitlements and 10 recipients are allowed in a request.   __REVOKE_ACCESS__ * Can only be requested for a single identity at a time. * You cannot use an access request to revoke access from an identity if that access has been granted by role membership or by birthright provisioning.  * Does not support self request. Only manager can request to revoke access for their directly managed employees. * If a `removeDate` is specified, then the access will be removed on that date and time only for roles and access profiles. Entitlements are currently unsupported for `removeDate`. * Roles, access profiles, and entitlements can be requested for revocation. * Revoke requests for entitlements are limited to 1 entitlement per access request currently. * [Roles, Access Profiles] You can specify a `removeDate` if the access doesn\'t already have a sunset date. The `removeDate` must be a future date, in the UTC timezone.  * Allows a manager to request to revoke access for direct employees. A token with ORG_ADMIN authority can also request to revoke access from anyone.  >**Note:** There is no indication to the approver in the IdentityNow UI that the approval request is for a revoke action. Take this into consideration when calling this API.  A token with API authority cannot be used to call this endpoint.
		         * @summary Submit an Access Request
		         * @param {AccessRequest} accessRequest
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createAccessRequest: function (accessRequest, axiosOptions) {
		            return localVarFp.createAccessRequest(accessRequest, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This endpoint returns the current access-request configuration.
		         * @summary Get Access Request Configuration
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getAccessRequestConfig: function (axiosOptions) {
		            return localVarFp.getAccessRequestConfig(axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * The Access Request Status API returns a list of access request statuses based on the specified query parameters. Any token with any authority can request their own status. A token with ORG_ADMIN authority is required to call this API to get a list of statuses for other users.
		         * @summary Access Request Status
		         * @param {string} [requestedFor] Filter the results by the identity for which the requests were made. *me* indicates the current user. Mutually exclusive with *regarding-identity*.
		         * @param {string} [requestedBy] Filter the results by the identity that made the requests. *me* indicates the current user. Mutually exclusive with *regarding-identity*.
		         * @param {string} [regardingIdentity] Filter the results by the specified identity which is either the requester or target of the requests. *me* indicates the current user. Mutually exclusive with *requested-for* and *requested-by*.
		         * @param {string} [assignedTo] Filter the results by the specified identity which is the owner of the Identity Request Work Item. *me* indicates the current user.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.
		         * @param {number} [limit] Max number of results to return.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. Defaults to 0 if not specified.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **accountActivityItemId**: *eq, in, ge, gt, le, lt, ne, isnull, sw*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **created, modified, accountActivityItemId, name**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listAccessRequestStatus: function (requestedFor, requestedBy, regardingIdentity, assignedTo, count, limit, offset, filters, sorters, axiosOptions) {
		            return localVarFp.listAccessRequestStatus(requestedFor, requestedBy, regardingIdentity, assignedTo, count, limit, offset, filters, sorters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This endpoint replaces the current access-request configuration. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Update Access Request Configuration
		         * @param {AccessRequestConfig} accessRequestConfig
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        setAccessRequestConfig: function (accessRequestConfig, axiosOptions) {
		            return localVarFp.setAccessRequestConfig(accessRequestConfig, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.AccessRequestsApiFactory = AccessRequestsApiFactory;
		/**
		 * AccessRequestsApi - object-oriented interface
		 * @export
		 * @class AccessRequestsApi
		 * @extends {BaseAPI}
		 */
		var AccessRequestsApi = /** @class */ (function (_super) {
		    __extends(AccessRequestsApi, _super);
		    function AccessRequestsApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * This API endpoint cancels a pending access request. An access request can be cancelled only if it has not passed the approval step. Any token with ORG_ADMIN authority or token of the user who originally requested the access request is required to cancel it.
		     * @summary Cancel Access Request
		     * @param {AccessRequestsApiCancelAccessRequestRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof AccessRequestsApi
		     */
		    AccessRequestsApi.prototype.cancelAccessRequest = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.AccessRequestsApiFp)(this.configuration).cancelAccessRequest(requestParameters.cancelAccessRequest, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This submits the access request into IdentityNow, where it will follow any IdentityNow approval processes.  Access requests are processed asynchronously by IdentityNow.  A success response from this endpoint means the request has been submitted to IDN and is queued for processing.  Because this endpoint is asynchronous, it will not return an error if you submit duplicate access requests in quick succession, or you submit an access request for access that is already in progress, approved, or rejected. It is best practice to check for any existing access requests that reference the same access items before submitting a new access request.  This can be accomplished by using the [access request status](https://developer.sailpoint.com/idn/api/v3/list-access-request-status) or the [pending access request approvals](https://developer.sailpoint.com/idn/api/v3/list-pending-approvals) endpoints.  You can also use the [search API](https://developer.sailpoint.com/idn/api/v3/search) to check the existing access items that an identity has before submitting an access request to ensure you are not requesting access that is already granted.  There are two types of access request:  __GRANT_ACCESS__ * Can be requested for multiple identities in a single request. * Supports self request and request on behalf of other users. Refer to the [Get Access Request Configuration](https://developer.sailpoint.com/idn/api/v3/get-access-request-config) endpoint for request configuration options.   * Allows any authenticated token (except API) to call this endpoint to request to grant access to themselves. Depending on the configuration, a user can request access for others. * Roles, access profiles and entitlements can be requested. * While requesting entitlements, maximum of 25 entitlements and 10 recipients are allowed in a request.   __REVOKE_ACCESS__ * Can only be requested for a single identity at a time. * You cannot use an access request to revoke access from an identity if that access has been granted by role membership or by birthright provisioning.  * Does not support self request. Only manager can request to revoke access for their directly managed employees. * If a `removeDate` is specified, then the access will be removed on that date and time only for roles and access profiles. Entitlements are currently unsupported for `removeDate`. * Roles, access profiles, and entitlements can be requested for revocation. * Revoke requests for entitlements are limited to 1 entitlement per access request currently. * [Roles, Access Profiles] You can specify a `removeDate` if the access doesn\'t already have a sunset date. The `removeDate` must be a future date, in the UTC timezone.  * Allows a manager to request to revoke access for direct employees. A token with ORG_ADMIN authority can also request to revoke access from anyone.  >**Note:** There is no indication to the approver in the IdentityNow UI that the approval request is for a revoke action. Take this into consideration when calling this API.  A token with API authority cannot be used to call this endpoint.
		     * @summary Submit an Access Request
		     * @param {AccessRequestsApiCreateAccessRequestRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof AccessRequestsApi
		     */
		    AccessRequestsApi.prototype.createAccessRequest = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.AccessRequestsApiFp)(this.configuration).createAccessRequest(requestParameters.accessRequest, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This endpoint returns the current access-request configuration.
		     * @summary Get Access Request Configuration
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof AccessRequestsApi
		     */
		    AccessRequestsApi.prototype.getAccessRequestConfig = function (axiosOptions) {
		        var _this = this;
		        return (0, exports.AccessRequestsApiFp)(this.configuration).getAccessRequestConfig(axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * The Access Request Status API returns a list of access request statuses based on the specified query parameters. Any token with any authority can request their own status. A token with ORG_ADMIN authority is required to call this API to get a list of statuses for other users.
		     * @summary Access Request Status
		     * @param {AccessRequestsApiListAccessRequestStatusRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof AccessRequestsApi
		     */
		    AccessRequestsApi.prototype.listAccessRequestStatus = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.AccessRequestsApiFp)(this.configuration).listAccessRequestStatus(requestParameters.requestedFor, requestParameters.requestedBy, requestParameters.regardingIdentity, requestParameters.assignedTo, requestParameters.count, requestParameters.limit, requestParameters.offset, requestParameters.filters, requestParameters.sorters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This endpoint replaces the current access-request configuration. A token with ORG_ADMIN authority is required to call this API.
		     * @summary Update Access Request Configuration
		     * @param {AccessRequestsApiSetAccessRequestConfigRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof AccessRequestsApi
		     */
		    AccessRequestsApi.prototype.setAccessRequestConfig = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.AccessRequestsApiFp)(this.configuration).setAccessRequestConfig(requestParameters.accessRequestConfig, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return AccessRequestsApi;
		}(base_1.BaseAPI));
		exports.AccessRequestsApi = AccessRequestsApi;
		/**
		 * AccountActivitiesApi - axios parameter creator
		 * @export
		 */
		var AccountActivitiesApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * This gets a single account activity by its id.
		         * @summary Get an Account Activity
		         * @param {string} id The account activity id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getAccountActivity: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getAccountActivity', 'id', id);
		                            localVarPath = "/account-activities/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets a collection of account activities that satisfy the given query parameters.
		         * @summary List Account Activities
		         * @param {string} [requestedFor] The identity that the activity was requested for. *me* indicates the current user. Mutually exclusive with *regarding-identity*.
		         * @param {string} [requestedBy] The identity that requested the activity. *me* indicates the current user. Mutually exclusive with *regarding-identity*.
		         * @param {string} [regardingIdentity] The specified identity will be either the requester or target of the account activity. *me* indicates the current user. Mutually exclusive with *requested-for* and *requested-by*.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **type**: *eq, in, ge, gt, le, lt, ne, isnull, sw*  **created**: *gt, lt, ge, le, eq, in, ne, isnull, sw*  **modified**: *gt, lt, ge, le, eq, in, ne, isnull, sw*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **type, created, modified**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listAccountActivities: function (requestedFor, requestedBy, regardingIdentity, limit, offset, count, filters, sorters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/account-activities";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (requestedFor !== undefined) {
		                                localVarQueryParameter['requested-for'] = requestedFor;
		                            }
		                            if (requestedBy !== undefined) {
		                                localVarQueryParameter['requested-by'] = requestedBy;
		                            }
		                            if (regardingIdentity !== undefined) {
		                                localVarQueryParameter['regarding-identity'] = regardingIdentity;
		                            }
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.AccountActivitiesApiAxiosParamCreator = AccountActivitiesApiAxiosParamCreator;
		/**
		 * AccountActivitiesApi - functional programming interface
		 * @export
		 */
		var AccountActivitiesApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.AccountActivitiesApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * This gets a single account activity by its id.
		         * @summary Get an Account Activity
		         * @param {string} id The account activity id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getAccountActivity: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getAccountActivity(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets a collection of account activities that satisfy the given query parameters.
		         * @summary List Account Activities
		         * @param {string} [requestedFor] The identity that the activity was requested for. *me* indicates the current user. Mutually exclusive with *regarding-identity*.
		         * @param {string} [requestedBy] The identity that requested the activity. *me* indicates the current user. Mutually exclusive with *regarding-identity*.
		         * @param {string} [regardingIdentity] The specified identity will be either the requester or target of the account activity. *me* indicates the current user. Mutually exclusive with *requested-for* and *requested-by*.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **type**: *eq, in, ge, gt, le, lt, ne, isnull, sw*  **created**: *gt, lt, ge, le, eq, in, ne, isnull, sw*  **modified**: *gt, lt, ge, le, eq, in, ne, isnull, sw*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **type, created, modified**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listAccountActivities: function (requestedFor, requestedBy, regardingIdentity, limit, offset, count, filters, sorters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listAccountActivities(requestedFor, requestedBy, regardingIdentity, limit, offset, count, filters, sorters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.AccountActivitiesApiFp = AccountActivitiesApiFp;
		/**
		 * AccountActivitiesApi - factory interface
		 * @export
		 */
		var AccountActivitiesApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.AccountActivitiesApiFp)(configuration);
		    return {
		        /**
		         * This gets a single account activity by its id.
		         * @summary Get an Account Activity
		         * @param {string} id The account activity id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getAccountActivity: function (id, axiosOptions) {
		            return localVarFp.getAccountActivity(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This gets a collection of account activities that satisfy the given query parameters.
		         * @summary List Account Activities
		         * @param {string} [requestedFor] The identity that the activity was requested for. *me* indicates the current user. Mutually exclusive with *regarding-identity*.
		         * @param {string} [requestedBy] The identity that requested the activity. *me* indicates the current user. Mutually exclusive with *regarding-identity*.
		         * @param {string} [regardingIdentity] The specified identity will be either the requester or target of the account activity. *me* indicates the current user. Mutually exclusive with *requested-for* and *requested-by*.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **type**: *eq, in, ge, gt, le, lt, ne, isnull, sw*  **created**: *gt, lt, ge, le, eq, in, ne, isnull, sw*  **modified**: *gt, lt, ge, le, eq, in, ne, isnull, sw*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **type, created, modified**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listAccountActivities: function (requestedFor, requestedBy, regardingIdentity, limit, offset, count, filters, sorters, axiosOptions) {
		            return localVarFp.listAccountActivities(requestedFor, requestedBy, regardingIdentity, limit, offset, count, filters, sorters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.AccountActivitiesApiFactory = AccountActivitiesApiFactory;
		/**
		 * AccountActivitiesApi - object-oriented interface
		 * @export
		 * @class AccountActivitiesApi
		 * @extends {BaseAPI}
		 */
		var AccountActivitiesApi = /** @class */ (function (_super) {
		    __extends(AccountActivitiesApi, _super);
		    function AccountActivitiesApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * This gets a single account activity by its id.
		     * @summary Get an Account Activity
		     * @param {AccountActivitiesApiGetAccountActivityRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof AccountActivitiesApi
		     */
		    AccountActivitiesApi.prototype.getAccountActivity = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.AccountActivitiesApiFp)(this.configuration).getAccountActivity(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This gets a collection of account activities that satisfy the given query parameters.
		     * @summary List Account Activities
		     * @param {AccountActivitiesApiListAccountActivitiesRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof AccountActivitiesApi
		     */
		    AccountActivitiesApi.prototype.listAccountActivities = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.AccountActivitiesApiFp)(this.configuration).listAccountActivities(requestParameters.requestedFor, requestParameters.requestedBy, requestParameters.regardingIdentity, requestParameters.limit, requestParameters.offset, requestParameters.count, requestParameters.filters, requestParameters.sorters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return AccountActivitiesApi;
		}(base_1.BaseAPI));
		exports.AccountActivitiesApi = AccountActivitiesApi;
		/**
		 * AccountUsagesApi - axios parameter creator
		 * @export
		 */
		var AccountUsagesApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * This API returns a summary of account usage insights for past 12 months.
		         * @summary Returns account usage insights
		         * @param {string} accountId ID of IDN account
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **date**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getUsagesByAccountId: function (accountId, limit, offset, count, sorters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'accountId' is not null or undefined
		                            (0, common_1.assertParamExists)('getUsagesByAccountId', 'accountId', accountId);
		                            localVarPath = "/account-usages/{accountId}/summaries"
		                                .replace("{".concat("accountId", "}"), encodeURIComponent(String(accountId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.AccountUsagesApiAxiosParamCreator = AccountUsagesApiAxiosParamCreator;
		/**
		 * AccountUsagesApi - functional programming interface
		 * @export
		 */
		var AccountUsagesApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.AccountUsagesApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * This API returns a summary of account usage insights for past 12 months.
		         * @summary Returns account usage insights
		         * @param {string} accountId ID of IDN account
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **date**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getUsagesByAccountId: function (accountId, limit, offset, count, sorters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getUsagesByAccountId(accountId, limit, offset, count, sorters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.AccountUsagesApiFp = AccountUsagesApiFp;
		/**
		 * AccountUsagesApi - factory interface
		 * @export
		 */
		var AccountUsagesApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.AccountUsagesApiFp)(configuration);
		    return {
		        /**
		         * This API returns a summary of account usage insights for past 12 months.
		         * @summary Returns account usage insights
		         * @param {string} accountId ID of IDN account
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **date**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getUsagesByAccountId: function (accountId, limit, offset, count, sorters, axiosOptions) {
		            return localVarFp.getUsagesByAccountId(accountId, limit, offset, count, sorters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.AccountUsagesApiFactory = AccountUsagesApiFactory;
		/**
		 * AccountUsagesApi - object-oriented interface
		 * @export
		 * @class AccountUsagesApi
		 * @extends {BaseAPI}
		 */
		var AccountUsagesApi = /** @class */ (function (_super) {
		    __extends(AccountUsagesApi, _super);
		    function AccountUsagesApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * This API returns a summary of account usage insights for past 12 months.
		     * @summary Returns account usage insights
		     * @param {AccountUsagesApiGetUsagesByAccountIdRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof AccountUsagesApi
		     */
		    AccountUsagesApi.prototype.getUsagesByAccountId = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.AccountUsagesApiFp)(this.configuration).getUsagesByAccountId(requestParameters.accountId, requestParameters.limit, requestParameters.offset, requestParameters.count, requestParameters.sorters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return AccountUsagesApi;
		}(base_1.BaseAPI));
		exports.AccountUsagesApi = AccountUsagesApi;
		/**
		 * AccountsApi - axios parameter creator
		 * @export
		 */
		var AccountsApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * This API submits an account creation task and returns the task ID.   The `sourceId` where this account will be created must be included in the `attributes` object. >**Note: This API only supports account creation for file based sources.** A token with ORG_ADMIN authority is required to call this API.
		         * @summary Create Account
		         * @param {AccountAttributesCreate} accountAttributesCreate
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createAccount: function (accountAttributesCreate, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'accountAttributesCreate' is not null or undefined
		                            (0, common_1.assertParamExists)('createAccount', 'accountAttributesCreate', accountAttributesCreate);
		                            localVarPath = "/accounts";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(accountAttributesCreate, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Use this API to delete an account.  This endpoint submits an account delete task and returns the task ID.  This endpoint only deletes the account from IdentityNow, not the source itself, which can result in the account\'s returning with the next aggregation between the source and IdentityNow.  To avoid this scenario, it is recommended that you [disable accounts](https://developer.sailpoint.com/idn/api/v3/disable-account) rather than delete them. This will also allow you to reenable the accounts in the future.  A token with ORG_ADMIN authority is required to call this API. >**NOTE: You can only delete accounts from sources of the \"DelimitedFile\" type.**
		         * @summary Delete Account
		         * @param {string} id Account ID.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteAccount: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('deleteAccount', 'id', id);
		                            localVarPath = "/accounts/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'DELETE' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API submits a task to disable the account and returns the task ID.   A token with ORG_ADMIN authority is required to call this API.
		         * @summary Disable Account
		         * @param {string} id The account id
		         * @param {AccountToggleRequest} accountToggleRequest
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        disableAccount: function (id, accountToggleRequest, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('disableAccount', 'id', id);
		                            // verify required parameter 'accountToggleRequest' is not null or undefined
		                            (0, common_1.assertParamExists)('disableAccount', 'accountToggleRequest', accountToggleRequest);
		                            localVarPath = "/accounts/{id}/disable"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(accountToggleRequest, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API submits a task to enable account and returns the task ID.   A token with ORG_ADMIN authority is required to call this API.
		         * @summary Enable Account
		         * @param {string} id The account id
		         * @param {AccountToggleRequest} accountToggleRequest
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        enableAccount: function (id, accountToggleRequest, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('enableAccount', 'id', id);
		                            // verify required parameter 'accountToggleRequest' is not null or undefined
		                            (0, common_1.assertParamExists)('enableAccount', 'accountToggleRequest', accountToggleRequest);
		                            localVarPath = "/accounts/{id}/enable"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(accountToggleRequest, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Use this API to return the details for a single account by its ID.   A token with ORG_ADMIN authority is required to call this API.
		         * @summary Account Details
		         * @param {string} id Account ID.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getAccount: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getAccount', 'id', id);
		                            localVarPath = "/accounts/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns entitlements of the account.   A token with ORG_ADMIN authority is required to call this API.
		         * @summary Account Entitlements
		         * @param {string} id The account id
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getAccountEntitlements: function (id, limit, offset, count, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getAccountEntitlements', 'id', id);
		                            localVarPath = "/accounts/{id}/entitlements"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This returns a list of accounts.   A token with ORG_ADMIN authority is required to call this API.
		         * @summary Accounts List
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in, sw*  **identityId**: *eq, in, sw*  **name**: *eq, in, sw*  **nativeIdentity**: *eq, in, sw*  **sourceId**: *eq, in, sw*  **uncorrelated**: *eq*  **identity.name**: *eq, in, sw*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **id, name, created, modified, sourceId, identityId, identity.id, nativeIdentity, uuid, manuallyCorrelated, identity.name**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listAccounts: function (limit, offset, count, filters, sorters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/accounts";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Use this API to update an account with a PUT request.  This endpoint submits an account update task and returns the task ID.  A token with ORG_ADMIN authority is required to call this API. >**NOTE: You can only use this PUT endpoint to update accounts from sources of the \"DelimitedFile\" type.**
		         * @summary Update Account
		         * @param {string} id Account ID.
		         * @param {AccountAttributes} accountAttributes
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putAccount: function (id, accountAttributes, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('putAccount', 'id', id);
		                            // verify required parameter 'accountAttributes' is not null or undefined
		                            (0, common_1.assertParamExists)('putAccount', 'accountAttributes', accountAttributes);
		                            localVarPath = "/accounts/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PUT' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(accountAttributes, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API asynchronously reloads the account directly from the connector and performs a one-time aggregation process.   A token with ORG_ADMIN authority is required to call this API.
		         * @summary Reload Account
		         * @param {string} id The account id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        reloadAccount: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('reloadAccount', 'id', id);
		                            localVarPath = "/accounts/{id}/reload"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API submits a task to unlock an account and returns the task ID.   A token with ORG_ADMIN authority is required to call this API.
		         * @summary Unlock Account
		         * @param {string} id The account id
		         * @param {AccountUnlockRequest} accountUnlockRequest
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        unlockAccount: function (id, accountUnlockRequest, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('unlockAccount', 'id', id);
		                            // verify required parameter 'accountUnlockRequest' is not null or undefined
		                            (0, common_1.assertParamExists)('unlockAccount', 'accountUnlockRequest', accountUnlockRequest);
		                            localVarPath = "/accounts/{id}/unlock"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(accountUnlockRequest, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Use this API to update the account with a PATCH request. This endpoint can only modify these fields: * `identityId` * `manuallyCorrelated` The request must provide a JSONPatch payload. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Update Account
		         * @param {string} id Account ID.
		         * @param {Array<JsonPatchOperation>} jsonPatchOperation A list of account update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateAccount: function (id, jsonPatchOperation, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('updateAccount', 'id', id);
		                            // verify required parameter 'jsonPatchOperation' is not null or undefined
		                            (0, common_1.assertParamExists)('updateAccount', 'jsonPatchOperation', jsonPatchOperation);
		                            localVarPath = "/accounts/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PATCH' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json-patch+json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(jsonPatchOperation, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.AccountsApiAxiosParamCreator = AccountsApiAxiosParamCreator;
		/**
		 * AccountsApi - functional programming interface
		 * @export
		 */
		var AccountsApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.AccountsApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * This API submits an account creation task and returns the task ID.   The `sourceId` where this account will be created must be included in the `attributes` object. >**Note: This API only supports account creation for file based sources.** A token with ORG_ADMIN authority is required to call this API.
		         * @summary Create Account
		         * @param {AccountAttributesCreate} accountAttributesCreate
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createAccount: function (accountAttributesCreate, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.createAccount(accountAttributesCreate, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Use this API to delete an account.  This endpoint submits an account delete task and returns the task ID.  This endpoint only deletes the account from IdentityNow, not the source itself, which can result in the account\'s returning with the next aggregation between the source and IdentityNow.  To avoid this scenario, it is recommended that you [disable accounts](https://developer.sailpoint.com/idn/api/v3/disable-account) rather than delete them. This will also allow you to reenable the accounts in the future.  A token with ORG_ADMIN authority is required to call this API. >**NOTE: You can only delete accounts from sources of the \"DelimitedFile\" type.**
		         * @summary Delete Account
		         * @param {string} id Account ID.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteAccount: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.deleteAccount(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API submits a task to disable the account and returns the task ID.   A token with ORG_ADMIN authority is required to call this API.
		         * @summary Disable Account
		         * @param {string} id The account id
		         * @param {AccountToggleRequest} accountToggleRequest
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        disableAccount: function (id, accountToggleRequest, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.disableAccount(id, accountToggleRequest, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API submits a task to enable account and returns the task ID.   A token with ORG_ADMIN authority is required to call this API.
		         * @summary Enable Account
		         * @param {string} id The account id
		         * @param {AccountToggleRequest} accountToggleRequest
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        enableAccount: function (id, accountToggleRequest, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.enableAccount(id, accountToggleRequest, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Use this API to return the details for a single account by its ID.   A token with ORG_ADMIN authority is required to call this API.
		         * @summary Account Details
		         * @param {string} id Account ID.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getAccount: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getAccount(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns entitlements of the account.   A token with ORG_ADMIN authority is required to call this API.
		         * @summary Account Entitlements
		         * @param {string} id The account id
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getAccountEntitlements: function (id, limit, offset, count, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getAccountEntitlements(id, limit, offset, count, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This returns a list of accounts.   A token with ORG_ADMIN authority is required to call this API.
		         * @summary Accounts List
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in, sw*  **identityId**: *eq, in, sw*  **name**: *eq, in, sw*  **nativeIdentity**: *eq, in, sw*  **sourceId**: *eq, in, sw*  **uncorrelated**: *eq*  **identity.name**: *eq, in, sw*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **id, name, created, modified, sourceId, identityId, identity.id, nativeIdentity, uuid, manuallyCorrelated, identity.name**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listAccounts: function (limit, offset, count, filters, sorters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listAccounts(limit, offset, count, filters, sorters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Use this API to update an account with a PUT request.  This endpoint submits an account update task and returns the task ID.  A token with ORG_ADMIN authority is required to call this API. >**NOTE: You can only use this PUT endpoint to update accounts from sources of the \"DelimitedFile\" type.**
		         * @summary Update Account
		         * @param {string} id Account ID.
		         * @param {AccountAttributes} accountAttributes
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putAccount: function (id, accountAttributes, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.putAccount(id, accountAttributes, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API asynchronously reloads the account directly from the connector and performs a one-time aggregation process.   A token with ORG_ADMIN authority is required to call this API.
		         * @summary Reload Account
		         * @param {string} id The account id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        reloadAccount: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.reloadAccount(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API submits a task to unlock an account and returns the task ID.   A token with ORG_ADMIN authority is required to call this API.
		         * @summary Unlock Account
		         * @param {string} id The account id
		         * @param {AccountUnlockRequest} accountUnlockRequest
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        unlockAccount: function (id, accountUnlockRequest, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.unlockAccount(id, accountUnlockRequest, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Use this API to update the account with a PATCH request. This endpoint can only modify these fields: * `identityId` * `manuallyCorrelated` The request must provide a JSONPatch payload. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Update Account
		         * @param {string} id Account ID.
		         * @param {Array<JsonPatchOperation>} jsonPatchOperation A list of account update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateAccount: function (id, jsonPatchOperation, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.updateAccount(id, jsonPatchOperation, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.AccountsApiFp = AccountsApiFp;
		/**
		 * AccountsApi - factory interface
		 * @export
		 */
		var AccountsApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.AccountsApiFp)(configuration);
		    return {
		        /**
		         * This API submits an account creation task and returns the task ID.   The `sourceId` where this account will be created must be included in the `attributes` object. >**Note: This API only supports account creation for file based sources.** A token with ORG_ADMIN authority is required to call this API.
		         * @summary Create Account
		         * @param {AccountAttributesCreate} accountAttributesCreate
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createAccount: function (accountAttributesCreate, axiosOptions) {
		            return localVarFp.createAccount(accountAttributesCreate, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Use this API to delete an account.  This endpoint submits an account delete task and returns the task ID.  This endpoint only deletes the account from IdentityNow, not the source itself, which can result in the account\'s returning with the next aggregation between the source and IdentityNow.  To avoid this scenario, it is recommended that you [disable accounts](https://developer.sailpoint.com/idn/api/v3/disable-account) rather than delete them. This will also allow you to reenable the accounts in the future.  A token with ORG_ADMIN authority is required to call this API. >**NOTE: You can only delete accounts from sources of the \"DelimitedFile\" type.**
		         * @summary Delete Account
		         * @param {string} id Account ID.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteAccount: function (id, axiosOptions) {
		            return localVarFp.deleteAccount(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API submits a task to disable the account and returns the task ID.   A token with ORG_ADMIN authority is required to call this API.
		         * @summary Disable Account
		         * @param {string} id The account id
		         * @param {AccountToggleRequest} accountToggleRequest
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        disableAccount: function (id, accountToggleRequest, axiosOptions) {
		            return localVarFp.disableAccount(id, accountToggleRequest, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API submits a task to enable account and returns the task ID.   A token with ORG_ADMIN authority is required to call this API.
		         * @summary Enable Account
		         * @param {string} id The account id
		         * @param {AccountToggleRequest} accountToggleRequest
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        enableAccount: function (id, accountToggleRequest, axiosOptions) {
		            return localVarFp.enableAccount(id, accountToggleRequest, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Use this API to return the details for a single account by its ID.   A token with ORG_ADMIN authority is required to call this API.
		         * @summary Account Details
		         * @param {string} id Account ID.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getAccount: function (id, axiosOptions) {
		            return localVarFp.getAccount(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API returns entitlements of the account.   A token with ORG_ADMIN authority is required to call this API.
		         * @summary Account Entitlements
		         * @param {string} id The account id
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getAccountEntitlements: function (id, limit, offset, count, axiosOptions) {
		            return localVarFp.getAccountEntitlements(id, limit, offset, count, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This returns a list of accounts.   A token with ORG_ADMIN authority is required to call this API.
		         * @summary Accounts List
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in, sw*  **identityId**: *eq, in, sw*  **name**: *eq, in, sw*  **nativeIdentity**: *eq, in, sw*  **sourceId**: *eq, in, sw*  **uncorrelated**: *eq*  **identity.name**: *eq, in, sw*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **id, name, created, modified, sourceId, identityId, identity.id, nativeIdentity, uuid, manuallyCorrelated, identity.name**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listAccounts: function (limit, offset, count, filters, sorters, axiosOptions) {
		            return localVarFp.listAccounts(limit, offset, count, filters, sorters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Use this API to update an account with a PUT request.  This endpoint submits an account update task and returns the task ID.  A token with ORG_ADMIN authority is required to call this API. >**NOTE: You can only use this PUT endpoint to update accounts from sources of the \"DelimitedFile\" type.**
		         * @summary Update Account
		         * @param {string} id Account ID.
		         * @param {AccountAttributes} accountAttributes
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putAccount: function (id, accountAttributes, axiosOptions) {
		            return localVarFp.putAccount(id, accountAttributes, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API asynchronously reloads the account directly from the connector and performs a one-time aggregation process.   A token with ORG_ADMIN authority is required to call this API.
		         * @summary Reload Account
		         * @param {string} id The account id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        reloadAccount: function (id, axiosOptions) {
		            return localVarFp.reloadAccount(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API submits a task to unlock an account and returns the task ID.   A token with ORG_ADMIN authority is required to call this API.
		         * @summary Unlock Account
		         * @param {string} id The account id
		         * @param {AccountUnlockRequest} accountUnlockRequest
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        unlockAccount: function (id, accountUnlockRequest, axiosOptions) {
		            return localVarFp.unlockAccount(id, accountUnlockRequest, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Use this API to update the account with a PATCH request. This endpoint can only modify these fields: * `identityId` * `manuallyCorrelated` The request must provide a JSONPatch payload. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Update Account
		         * @param {string} id Account ID.
		         * @param {Array<JsonPatchOperation>} jsonPatchOperation A list of account update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateAccount: function (id, jsonPatchOperation, axiosOptions) {
		            return localVarFp.updateAccount(id, jsonPatchOperation, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.AccountsApiFactory = AccountsApiFactory;
		/**
		 * AccountsApi - object-oriented interface
		 * @export
		 * @class AccountsApi
		 * @extends {BaseAPI}
		 */
		var AccountsApi = /** @class */ (function (_super) {
		    __extends(AccountsApi, _super);
		    function AccountsApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * This API submits an account creation task and returns the task ID.   The `sourceId` where this account will be created must be included in the `attributes` object. >**Note: This API only supports account creation for file based sources.** A token with ORG_ADMIN authority is required to call this API.
		     * @summary Create Account
		     * @param {AccountsApiCreateAccountRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof AccountsApi
		     */
		    AccountsApi.prototype.createAccount = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.AccountsApiFp)(this.configuration).createAccount(requestParameters.accountAttributesCreate, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Use this API to delete an account.  This endpoint submits an account delete task and returns the task ID.  This endpoint only deletes the account from IdentityNow, not the source itself, which can result in the account\'s returning with the next aggregation between the source and IdentityNow.  To avoid this scenario, it is recommended that you [disable accounts](https://developer.sailpoint.com/idn/api/v3/disable-account) rather than delete them. This will also allow you to reenable the accounts in the future.  A token with ORG_ADMIN authority is required to call this API. >**NOTE: You can only delete accounts from sources of the \"DelimitedFile\" type.**
		     * @summary Delete Account
		     * @param {AccountsApiDeleteAccountRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof AccountsApi
		     */
		    AccountsApi.prototype.deleteAccount = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.AccountsApiFp)(this.configuration).deleteAccount(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API submits a task to disable the account and returns the task ID.   A token with ORG_ADMIN authority is required to call this API.
		     * @summary Disable Account
		     * @param {AccountsApiDisableAccountRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof AccountsApi
		     */
		    AccountsApi.prototype.disableAccount = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.AccountsApiFp)(this.configuration).disableAccount(requestParameters.id, requestParameters.accountToggleRequest, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API submits a task to enable account and returns the task ID.   A token with ORG_ADMIN authority is required to call this API.
		     * @summary Enable Account
		     * @param {AccountsApiEnableAccountRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof AccountsApi
		     */
		    AccountsApi.prototype.enableAccount = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.AccountsApiFp)(this.configuration).enableAccount(requestParameters.id, requestParameters.accountToggleRequest, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Use this API to return the details for a single account by its ID.   A token with ORG_ADMIN authority is required to call this API.
		     * @summary Account Details
		     * @param {AccountsApiGetAccountRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof AccountsApi
		     */
		    AccountsApi.prototype.getAccount = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.AccountsApiFp)(this.configuration).getAccount(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API returns entitlements of the account.   A token with ORG_ADMIN authority is required to call this API.
		     * @summary Account Entitlements
		     * @param {AccountsApiGetAccountEntitlementsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof AccountsApi
		     */
		    AccountsApi.prototype.getAccountEntitlements = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.AccountsApiFp)(this.configuration).getAccountEntitlements(requestParameters.id, requestParameters.limit, requestParameters.offset, requestParameters.count, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This returns a list of accounts.   A token with ORG_ADMIN authority is required to call this API.
		     * @summary Accounts List
		     * @param {AccountsApiListAccountsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof AccountsApi
		     */
		    AccountsApi.prototype.listAccounts = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.AccountsApiFp)(this.configuration).listAccounts(requestParameters.limit, requestParameters.offset, requestParameters.count, requestParameters.filters, requestParameters.sorters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Use this API to update an account with a PUT request.  This endpoint submits an account update task and returns the task ID.  A token with ORG_ADMIN authority is required to call this API. >**NOTE: You can only use this PUT endpoint to update accounts from sources of the \"DelimitedFile\" type.**
		     * @summary Update Account
		     * @param {AccountsApiPutAccountRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof AccountsApi
		     */
		    AccountsApi.prototype.putAccount = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.AccountsApiFp)(this.configuration).putAccount(requestParameters.id, requestParameters.accountAttributes, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API asynchronously reloads the account directly from the connector and performs a one-time aggregation process.   A token with ORG_ADMIN authority is required to call this API.
		     * @summary Reload Account
		     * @param {AccountsApiReloadAccountRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof AccountsApi
		     */
		    AccountsApi.prototype.reloadAccount = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.AccountsApiFp)(this.configuration).reloadAccount(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API submits a task to unlock an account and returns the task ID.   A token with ORG_ADMIN authority is required to call this API.
		     * @summary Unlock Account
		     * @param {AccountsApiUnlockAccountRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof AccountsApi
		     */
		    AccountsApi.prototype.unlockAccount = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.AccountsApiFp)(this.configuration).unlockAccount(requestParameters.id, requestParameters.accountUnlockRequest, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Use this API to update the account with a PATCH request. This endpoint can only modify these fields: * `identityId` * `manuallyCorrelated` The request must provide a JSONPatch payload. A token with ORG_ADMIN authority is required to call this API.
		     * @summary Update Account
		     * @param {AccountsApiUpdateAccountRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof AccountsApi
		     */
		    AccountsApi.prototype.updateAccount = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.AccountsApiFp)(this.configuration).updateAccount(requestParameters.id, requestParameters.jsonPatchOperation, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return AccountsApi;
		}(base_1.BaseAPI));
		exports.AccountsApi = AccountsApi;
		/**
		 * AuthUserApi - axios parameter creator
		 * @export
		 */
		var AuthUserApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * Return the specified user\'s authentication system details.
		         * @summary Auth User Details
		         * @param {string} id Identity ID
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getAuthUser: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getAuthUser', 'id', id);
		                            localVarPath = "/auth-users/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Use a PATCH request to update an existing user in the authentication system. Use this endpoint to modify these fields:    * `capabilities`  A \'400.1.1 Illegal update attempt\' detail code indicates that you attempted to PATCH a field that is not allowed.
		         * @summary Auth User Update
		         * @param {string} id Identity ID
		         * @param {Array<JsonPatchOperation>} jsonPatchOperation A list of auth user update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchAuthUser: function (id, jsonPatchOperation, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('patchAuthUser', 'id', id);
		                            // verify required parameter 'jsonPatchOperation' is not null or undefined
		                            (0, common_1.assertParamExists)('patchAuthUser', 'jsonPatchOperation', jsonPatchOperation);
		                            localVarPath = "/auth-users/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PATCH' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json-patch+json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(jsonPatchOperation, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.AuthUserApiAxiosParamCreator = AuthUserApiAxiosParamCreator;
		/**
		 * AuthUserApi - functional programming interface
		 * @export
		 */
		var AuthUserApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.AuthUserApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * Return the specified user\'s authentication system details.
		         * @summary Auth User Details
		         * @param {string} id Identity ID
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getAuthUser: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getAuthUser(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Use a PATCH request to update an existing user in the authentication system. Use this endpoint to modify these fields:    * `capabilities`  A \'400.1.1 Illegal update attempt\' detail code indicates that you attempted to PATCH a field that is not allowed.
		         * @summary Auth User Update
		         * @param {string} id Identity ID
		         * @param {Array<JsonPatchOperation>} jsonPatchOperation A list of auth user update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchAuthUser: function (id, jsonPatchOperation, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.patchAuthUser(id, jsonPatchOperation, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.AuthUserApiFp = AuthUserApiFp;
		/**
		 * AuthUserApi - factory interface
		 * @export
		 */
		var AuthUserApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.AuthUserApiFp)(configuration);
		    return {
		        /**
		         * Return the specified user\'s authentication system details.
		         * @summary Auth User Details
		         * @param {string} id Identity ID
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getAuthUser: function (id, axiosOptions) {
		            return localVarFp.getAuthUser(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Use a PATCH request to update an existing user in the authentication system. Use this endpoint to modify these fields:    * `capabilities`  A \'400.1.1 Illegal update attempt\' detail code indicates that you attempted to PATCH a field that is not allowed.
		         * @summary Auth User Update
		         * @param {string} id Identity ID
		         * @param {Array<JsonPatchOperation>} jsonPatchOperation A list of auth user update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchAuthUser: function (id, jsonPatchOperation, axiosOptions) {
		            return localVarFp.patchAuthUser(id, jsonPatchOperation, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.AuthUserApiFactory = AuthUserApiFactory;
		/**
		 * AuthUserApi - object-oriented interface
		 * @export
		 * @class AuthUserApi
		 * @extends {BaseAPI}
		 */
		var AuthUserApi = /** @class */ (function (_super) {
		    __extends(AuthUserApi, _super);
		    function AuthUserApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * Return the specified user\'s authentication system details.
		     * @summary Auth User Details
		     * @param {AuthUserApiGetAuthUserRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof AuthUserApi
		     */
		    AuthUserApi.prototype.getAuthUser = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.AuthUserApiFp)(this.configuration).getAuthUser(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Use a PATCH request to update an existing user in the authentication system. Use this endpoint to modify these fields:    * `capabilities`  A \'400.1.1 Illegal update attempt\' detail code indicates that you attempted to PATCH a field that is not allowed.
		     * @summary Auth User Update
		     * @param {AuthUserApiPatchAuthUserRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof AuthUserApi
		     */
		    AuthUserApi.prototype.patchAuthUser = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.AuthUserApiFp)(this.configuration).patchAuthUser(requestParameters.id, requestParameters.jsonPatchOperation, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return AuthUserApi;
		}(base_1.BaseAPI));
		exports.AuthUserApi = AuthUserApi;
		/**
		 * BrandingApi - axios parameter creator
		 * @export
		 */
		var BrandingApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * This API endpoint creates a branding item. A token with API, ORG_ADMIN authority is required to call this API.
		         * @summary Create a branding item
		         * @param {string} name name of branding item
		         * @param {string} productName product name
		         * @param {string} [actionButtonColor] hex value of color for action button
		         * @param {string} [activeLinkColor] hex value of color for link
		         * @param {string} [navigationColor] hex value of color for navigation bar
		         * @param {string} [emailFromAddress] email from address
		         * @param {string} [loginInformationalMessage] login information message
		         * @param {any} [fileStandard] png file with logo
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createBrandingItem: function (name, productName, actionButtonColor, activeLinkColor, navigationColor, emailFromAddress, loginInformationalMessage, fileStandard, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, localVarFormParams, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'name' is not null or undefined
		                            (0, common_1.assertParamExists)('createBrandingItem', 'name', name);
		                            // verify required parameter 'productName' is not null or undefined
		                            (0, common_1.assertParamExists)('createBrandingItem', 'productName', productName);
		                            localVarPath = "/brandings";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            localVarFormParams = new ((configuration && configuration.formDataCtor) || FormData)();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (name !== undefined) {
		                                localVarFormParams.append('name', name);
		                            }
		                            if (productName !== undefined) {
		                                localVarFormParams.append('productName', productName);
		                            }
		                            if (actionButtonColor !== undefined) {
		                                localVarFormParams.append('actionButtonColor', actionButtonColor);
		                            }
		                            if (activeLinkColor !== undefined) {
		                                localVarFormParams.append('activeLinkColor', activeLinkColor);
		                            }
		                            if (navigationColor !== undefined) {
		                                localVarFormParams.append('navigationColor', navigationColor);
		                            }
		                            if (emailFromAddress !== undefined) {
		                                localVarFormParams.append('emailFromAddress', emailFromAddress);
		                            }
		                            if (loginInformationalMessage !== undefined) {
		                                localVarFormParams.append('loginInformationalMessage', loginInformationalMessage);
		                            }
		                            if (fileStandard !== undefined) {
		                                localVarFormParams.append('fileStandard', fileStandard);
		                            }
		                            localVarHeaderParameter['Content-Type'] = 'multipart/form-data';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = localVarFormParams;
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API endpoint delete information for an existing branding item by name. A token with API, ORG_ADMIN authority is required to call this API.
		         * @summary Delete a branding item
		         * @param {string} name The name of the branding item to be deleted
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteBranding: function (name, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'name' is not null or undefined
		                            (0, common_1.assertParamExists)('deleteBranding', 'name', name);
		                            localVarPath = "/brandings/{name}"
		                                .replace("{".concat("name", "}"), encodeURIComponent(String(name)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'DELETE' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API endpoint retrieves information for an existing branding item by name. A token with API, ORG_ADMIN authority is required to call this API.
		         * @summary Get a branding item
		         * @param {string} name The name of the branding item to be retrieved
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getBranding: function (name, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'name' is not null or undefined
		                            (0, common_1.assertParamExists)('getBranding', 'name', name);
		                            localVarPath = "/brandings/{name}"
		                                .replace("{".concat("name", "}"), encodeURIComponent(String(name)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API endpoint returns a list of branding items.  A token with API, ORG_ADMIN authority is required to call this API.
		         * @summary List of branding items
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getBrandingList: function (axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/brandings";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API endpoint updates information for an existing branding item. A token with API, ORG_ADMIN authority is required to call this API.
		         * @summary Update a branding item
		         * @param {string} name The name of the branding item to be retrieved
		         * @param {string} name2 name of branding item
		         * @param {string} productName product name
		         * @param {string} [actionButtonColor] hex value of color for action button
		         * @param {string} [activeLinkColor] hex value of color for link
		         * @param {string} [navigationColor] hex value of color for navigation bar
		         * @param {string} [emailFromAddress] email from address
		         * @param {string} [loginInformationalMessage] login information message
		         * @param {any} [fileStandard] png file with logo
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        setBrandingItem: function (name, name2, productName, actionButtonColor, activeLinkColor, navigationColor, emailFromAddress, loginInformationalMessage, fileStandard, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, localVarFormParams, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'name' is not null or undefined
		                            (0, common_1.assertParamExists)('setBrandingItem', 'name', name);
		                            // verify required parameter 'name2' is not null or undefined
		                            (0, common_1.assertParamExists)('setBrandingItem', 'name2', name2);
		                            // verify required parameter 'productName' is not null or undefined
		                            (0, common_1.assertParamExists)('setBrandingItem', 'productName', productName);
		                            localVarPath = "/brandings/{name}"
		                                .replace("{".concat("name", "}"), encodeURIComponent(String(name)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PUT' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            localVarFormParams = new ((configuration && configuration.formDataCtor) || FormData)();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (name2 !== undefined) {
		                                localVarFormParams.append('name', name2);
		                            }
		                            if (productName !== undefined) {
		                                localVarFormParams.append('productName', productName);
		                            }
		                            if (actionButtonColor !== undefined) {
		                                localVarFormParams.append('actionButtonColor', actionButtonColor);
		                            }
		                            if (activeLinkColor !== undefined) {
		                                localVarFormParams.append('activeLinkColor', activeLinkColor);
		                            }
		                            if (navigationColor !== undefined) {
		                                localVarFormParams.append('navigationColor', navigationColor);
		                            }
		                            if (emailFromAddress !== undefined) {
		                                localVarFormParams.append('emailFromAddress', emailFromAddress);
		                            }
		                            if (loginInformationalMessage !== undefined) {
		                                localVarFormParams.append('loginInformationalMessage', loginInformationalMessage);
		                            }
		                            if (fileStandard !== undefined) {
		                                localVarFormParams.append('fileStandard', fileStandard);
		                            }
		                            localVarHeaderParameter['Content-Type'] = 'multipart/form-data';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = localVarFormParams;
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.BrandingApiAxiosParamCreator = BrandingApiAxiosParamCreator;
		/**
		 * BrandingApi - functional programming interface
		 * @export
		 */
		var BrandingApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.BrandingApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * This API endpoint creates a branding item. A token with API, ORG_ADMIN authority is required to call this API.
		         * @summary Create a branding item
		         * @param {string} name name of branding item
		         * @param {string} productName product name
		         * @param {string} [actionButtonColor] hex value of color for action button
		         * @param {string} [activeLinkColor] hex value of color for link
		         * @param {string} [navigationColor] hex value of color for navigation bar
		         * @param {string} [emailFromAddress] email from address
		         * @param {string} [loginInformationalMessage] login information message
		         * @param {any} [fileStandard] png file with logo
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createBrandingItem: function (name, productName, actionButtonColor, activeLinkColor, navigationColor, emailFromAddress, loginInformationalMessage, fileStandard, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.createBrandingItem(name, productName, actionButtonColor, activeLinkColor, navigationColor, emailFromAddress, loginInformationalMessage, fileStandard, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API endpoint delete information for an existing branding item by name. A token with API, ORG_ADMIN authority is required to call this API.
		         * @summary Delete a branding item
		         * @param {string} name The name of the branding item to be deleted
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteBranding: function (name, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.deleteBranding(name, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API endpoint retrieves information for an existing branding item by name. A token with API, ORG_ADMIN authority is required to call this API.
		         * @summary Get a branding item
		         * @param {string} name The name of the branding item to be retrieved
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getBranding: function (name, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getBranding(name, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API endpoint returns a list of branding items.  A token with API, ORG_ADMIN authority is required to call this API.
		         * @summary List of branding items
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getBrandingList: function (axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getBrandingList(axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API endpoint updates information for an existing branding item. A token with API, ORG_ADMIN authority is required to call this API.
		         * @summary Update a branding item
		         * @param {string} name The name of the branding item to be retrieved
		         * @param {string} name2 name of branding item
		         * @param {string} productName product name
		         * @param {string} [actionButtonColor] hex value of color for action button
		         * @param {string} [activeLinkColor] hex value of color for link
		         * @param {string} [navigationColor] hex value of color for navigation bar
		         * @param {string} [emailFromAddress] email from address
		         * @param {string} [loginInformationalMessage] login information message
		         * @param {any} [fileStandard] png file with logo
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        setBrandingItem: function (name, name2, productName, actionButtonColor, activeLinkColor, navigationColor, emailFromAddress, loginInformationalMessage, fileStandard, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.setBrandingItem(name, name2, productName, actionButtonColor, activeLinkColor, navigationColor, emailFromAddress, loginInformationalMessage, fileStandard, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.BrandingApiFp = BrandingApiFp;
		/**
		 * BrandingApi - factory interface
		 * @export
		 */
		var BrandingApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.BrandingApiFp)(configuration);
		    return {
		        /**
		         * This API endpoint creates a branding item. A token with API, ORG_ADMIN authority is required to call this API.
		         * @summary Create a branding item
		         * @param {string} name name of branding item
		         * @param {string} productName product name
		         * @param {string} [actionButtonColor] hex value of color for action button
		         * @param {string} [activeLinkColor] hex value of color for link
		         * @param {string} [navigationColor] hex value of color for navigation bar
		         * @param {string} [emailFromAddress] email from address
		         * @param {string} [loginInformationalMessage] login information message
		         * @param {any} [fileStandard] png file with logo
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createBrandingItem: function (name, productName, actionButtonColor, activeLinkColor, navigationColor, emailFromAddress, loginInformationalMessage, fileStandard, axiosOptions) {
		            return localVarFp.createBrandingItem(name, productName, actionButtonColor, activeLinkColor, navigationColor, emailFromAddress, loginInformationalMessage, fileStandard, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API endpoint delete information for an existing branding item by name. A token with API, ORG_ADMIN authority is required to call this API.
		         * @summary Delete a branding item
		         * @param {string} name The name of the branding item to be deleted
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteBranding: function (name, axiosOptions) {
		            return localVarFp.deleteBranding(name, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API endpoint retrieves information for an existing branding item by name. A token with API, ORG_ADMIN authority is required to call this API.
		         * @summary Get a branding item
		         * @param {string} name The name of the branding item to be retrieved
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getBranding: function (name, axiosOptions) {
		            return localVarFp.getBranding(name, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API endpoint returns a list of branding items.  A token with API, ORG_ADMIN authority is required to call this API.
		         * @summary List of branding items
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getBrandingList: function (axiosOptions) {
		            return localVarFp.getBrandingList(axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API endpoint updates information for an existing branding item. A token with API, ORG_ADMIN authority is required to call this API.
		         * @summary Update a branding item
		         * @param {string} name The name of the branding item to be retrieved
		         * @param {string} name2 name of branding item
		         * @param {string} productName product name
		         * @param {string} [actionButtonColor] hex value of color for action button
		         * @param {string} [activeLinkColor] hex value of color for link
		         * @param {string} [navigationColor] hex value of color for navigation bar
		         * @param {string} [emailFromAddress] email from address
		         * @param {string} [loginInformationalMessage] login information message
		         * @param {any} [fileStandard] png file with logo
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        setBrandingItem: function (name, name2, productName, actionButtonColor, activeLinkColor, navigationColor, emailFromAddress, loginInformationalMessage, fileStandard, axiosOptions) {
		            return localVarFp.setBrandingItem(name, name2, productName, actionButtonColor, activeLinkColor, navigationColor, emailFromAddress, loginInformationalMessage, fileStandard, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.BrandingApiFactory = BrandingApiFactory;
		/**
		 * BrandingApi - object-oriented interface
		 * @export
		 * @class BrandingApi
		 * @extends {BaseAPI}
		 */
		var BrandingApi = /** @class */ (function (_super) {
		    __extends(BrandingApi, _super);
		    function BrandingApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * This API endpoint creates a branding item. A token with API, ORG_ADMIN authority is required to call this API.
		     * @summary Create a branding item
		     * @param {BrandingApiCreateBrandingItemRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof BrandingApi
		     */
		    BrandingApi.prototype.createBrandingItem = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.BrandingApiFp)(this.configuration).createBrandingItem(requestParameters.name, requestParameters.productName, requestParameters.actionButtonColor, requestParameters.activeLinkColor, requestParameters.navigationColor, requestParameters.emailFromAddress, requestParameters.loginInformationalMessage, requestParameters.fileStandard, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API endpoint delete information for an existing branding item by name. A token with API, ORG_ADMIN authority is required to call this API.
		     * @summary Delete a branding item
		     * @param {BrandingApiDeleteBrandingRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof BrandingApi
		     */
		    BrandingApi.prototype.deleteBranding = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.BrandingApiFp)(this.configuration).deleteBranding(requestParameters.name, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API endpoint retrieves information for an existing branding item by name. A token with API, ORG_ADMIN authority is required to call this API.
		     * @summary Get a branding item
		     * @param {BrandingApiGetBrandingRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof BrandingApi
		     */
		    BrandingApi.prototype.getBranding = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.BrandingApiFp)(this.configuration).getBranding(requestParameters.name, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API endpoint returns a list of branding items.  A token with API, ORG_ADMIN authority is required to call this API.
		     * @summary List of branding items
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof BrandingApi
		     */
		    BrandingApi.prototype.getBrandingList = function (axiosOptions) {
		        var _this = this;
		        return (0, exports.BrandingApiFp)(this.configuration).getBrandingList(axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API endpoint updates information for an existing branding item. A token with API, ORG_ADMIN authority is required to call this API.
		     * @summary Update a branding item
		     * @param {BrandingApiSetBrandingItemRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof BrandingApi
		     */
		    BrandingApi.prototype.setBrandingItem = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.BrandingApiFp)(this.configuration).setBrandingItem(requestParameters.name, requestParameters.name2, requestParameters.productName, requestParameters.actionButtonColor, requestParameters.activeLinkColor, requestParameters.navigationColor, requestParameters.emailFromAddress, requestParameters.loginInformationalMessage, requestParameters.fileStandard, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return BrandingApi;
		}(base_1.BaseAPI));
		exports.BrandingApi = BrandingApi;
		/**
		 * CertificationCampaignFiltersApi - axios parameter creator
		 * @export
		 */
		var CertificationCampaignFiltersApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * Create a campaign Filter based on filter details and criteria.
		         * @summary Create a Campaign Filter
		         * @param {CampaignFilterDetails} campaignFilterDetails
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createCampaignFilter: function (campaignFilterDetails, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'campaignFilterDetails' is not null or undefined
		                            (0, common_1.assertParamExists)('createCampaignFilter', 'campaignFilterDetails', campaignFilterDetails);
		                            localVarPath = "/campaign-filters";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(campaignFilterDetails, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Deletes campaign filters whose Ids are specified in the provided list of campaign filter Ids. Authorized callers must be an ORG_ADMIN or a CERT_ADMIN.
		         * @summary Deletes Campaign Filters
		         * @param {Array<string>} requestBody A json list of IDs of campaign filters to delete.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteCampaignFilters: function (requestBody, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'requestBody' is not null or undefined
		                            (0, common_1.assertParamExists)('deleteCampaignFilters', 'requestBody', requestBody);
		                            localVarPath = "/campaign-filters/delete";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(requestBody, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Retrieves information for an existing campaign filter using the filter\'s ID.
		         * @summary Get Campaign Filter by ID
		         * @param {string} filterId The ID of the campaign filter to be retrieved.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getCampaignFilterById: function (filterId, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'filterId' is not null or undefined
		                            (0, common_1.assertParamExists)('getCampaignFilterById', 'filterId', filterId);
		                            localVarPath = "/campaign-filters/{id}"
		                                .replace("{".concat("filterId", "}"), encodeURIComponent(String(filterId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Lists all Campaign Filters. Scope can be reduced via standard V3 query params.  All Campaign Filters matching the query params
		         * @summary List Campaign Filters
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [start] Start/Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [includeSystemFilters] If true, include system filters in the count and results, exclude them otherwise. If not provided any value for it then by default it is true.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listCampaignFilters: function (limit, start, includeSystemFilters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/campaign-filters";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (start !== undefined) {
		                                localVarQueryParameter['start'] = start;
		                            }
		                            if (includeSystemFilters !== undefined) {
		                                localVarQueryParameter['includeSystemFilters'] = includeSystemFilters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Updates an existing campaign filter using the filter\'s ID.
		         * @summary Updates a Campaign Filter
		         * @param {string} filterId The ID of the campaign filter being modified.
		         * @param {CampaignFilterDetails} campaignFilterDetails A campaign filter details with updated field values.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateCampaignFilter: function (filterId, campaignFilterDetails, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'filterId' is not null or undefined
		                            (0, common_1.assertParamExists)('updateCampaignFilter', 'filterId', filterId);
		                            // verify required parameter 'campaignFilterDetails' is not null or undefined
		                            (0, common_1.assertParamExists)('updateCampaignFilter', 'campaignFilterDetails', campaignFilterDetails);
		                            localVarPath = "/campaign-filters/{id}"
		                                .replace("{".concat("filterId", "}"), encodeURIComponent(String(filterId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(campaignFilterDetails, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.CertificationCampaignFiltersApiAxiosParamCreator = CertificationCampaignFiltersApiAxiosParamCreator;
		/**
		 * CertificationCampaignFiltersApi - functional programming interface
		 * @export
		 */
		var CertificationCampaignFiltersApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.CertificationCampaignFiltersApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * Create a campaign Filter based on filter details and criteria.
		         * @summary Create a Campaign Filter
		         * @param {CampaignFilterDetails} campaignFilterDetails
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createCampaignFilter: function (campaignFilterDetails, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.createCampaignFilter(campaignFilterDetails, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Deletes campaign filters whose Ids are specified in the provided list of campaign filter Ids. Authorized callers must be an ORG_ADMIN or a CERT_ADMIN.
		         * @summary Deletes Campaign Filters
		         * @param {Array<string>} requestBody A json list of IDs of campaign filters to delete.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteCampaignFilters: function (requestBody, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.deleteCampaignFilters(requestBody, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Retrieves information for an existing campaign filter using the filter\'s ID.
		         * @summary Get Campaign Filter by ID
		         * @param {string} filterId The ID of the campaign filter to be retrieved.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getCampaignFilterById: function (filterId, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getCampaignFilterById(filterId, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Lists all Campaign Filters. Scope can be reduced via standard V3 query params.  All Campaign Filters matching the query params
		         * @summary List Campaign Filters
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [start] Start/Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [includeSystemFilters] If true, include system filters in the count and results, exclude them otherwise. If not provided any value for it then by default it is true.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listCampaignFilters: function (limit, start, includeSystemFilters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listCampaignFilters(limit, start, includeSystemFilters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Updates an existing campaign filter using the filter\'s ID.
		         * @summary Updates a Campaign Filter
		         * @param {string} filterId The ID of the campaign filter being modified.
		         * @param {CampaignFilterDetails} campaignFilterDetails A campaign filter details with updated field values.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateCampaignFilter: function (filterId, campaignFilterDetails, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.updateCampaignFilter(filterId, campaignFilterDetails, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.CertificationCampaignFiltersApiFp = CertificationCampaignFiltersApiFp;
		/**
		 * CertificationCampaignFiltersApi - factory interface
		 * @export
		 */
		var CertificationCampaignFiltersApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.CertificationCampaignFiltersApiFp)(configuration);
		    return {
		        /**
		         * Create a campaign Filter based on filter details and criteria.
		         * @summary Create a Campaign Filter
		         * @param {CampaignFilterDetails} campaignFilterDetails
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createCampaignFilter: function (campaignFilterDetails, axiosOptions) {
		            return localVarFp.createCampaignFilter(campaignFilterDetails, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Deletes campaign filters whose Ids are specified in the provided list of campaign filter Ids. Authorized callers must be an ORG_ADMIN or a CERT_ADMIN.
		         * @summary Deletes Campaign Filters
		         * @param {Array<string>} requestBody A json list of IDs of campaign filters to delete.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteCampaignFilters: function (requestBody, axiosOptions) {
		            return localVarFp.deleteCampaignFilters(requestBody, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Retrieves information for an existing campaign filter using the filter\'s ID.
		         * @summary Get Campaign Filter by ID
		         * @param {string} filterId The ID of the campaign filter to be retrieved.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getCampaignFilterById: function (filterId, axiosOptions) {
		            return localVarFp.getCampaignFilterById(filterId, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Lists all Campaign Filters. Scope can be reduced via standard V3 query params.  All Campaign Filters matching the query params
		         * @summary List Campaign Filters
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [start] Start/Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [includeSystemFilters] If true, include system filters in the count and results, exclude them otherwise. If not provided any value for it then by default it is true.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listCampaignFilters: function (limit, start, includeSystemFilters, axiosOptions) {
		            return localVarFp.listCampaignFilters(limit, start, includeSystemFilters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Updates an existing campaign filter using the filter\'s ID.
		         * @summary Updates a Campaign Filter
		         * @param {string} filterId The ID of the campaign filter being modified.
		         * @param {CampaignFilterDetails} campaignFilterDetails A campaign filter details with updated field values.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateCampaignFilter: function (filterId, campaignFilterDetails, axiosOptions) {
		            return localVarFp.updateCampaignFilter(filterId, campaignFilterDetails, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.CertificationCampaignFiltersApiFactory = CertificationCampaignFiltersApiFactory;
		/**
		 * CertificationCampaignFiltersApi - object-oriented interface
		 * @export
		 * @class CertificationCampaignFiltersApi
		 * @extends {BaseAPI}
		 */
		var CertificationCampaignFiltersApi = /** @class */ (function (_super) {
		    __extends(CertificationCampaignFiltersApi, _super);
		    function CertificationCampaignFiltersApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * Create a campaign Filter based on filter details and criteria.
		     * @summary Create a Campaign Filter
		     * @param {CertificationCampaignFiltersApiCreateCampaignFilterRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof CertificationCampaignFiltersApi
		     */
		    CertificationCampaignFiltersApi.prototype.createCampaignFilter = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.CertificationCampaignFiltersApiFp)(this.configuration).createCampaignFilter(requestParameters.campaignFilterDetails, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Deletes campaign filters whose Ids are specified in the provided list of campaign filter Ids. Authorized callers must be an ORG_ADMIN or a CERT_ADMIN.
		     * @summary Deletes Campaign Filters
		     * @param {CertificationCampaignFiltersApiDeleteCampaignFiltersRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof CertificationCampaignFiltersApi
		     */
		    CertificationCampaignFiltersApi.prototype.deleteCampaignFilters = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.CertificationCampaignFiltersApiFp)(this.configuration).deleteCampaignFilters(requestParameters.requestBody, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Retrieves information for an existing campaign filter using the filter\'s ID.
		     * @summary Get Campaign Filter by ID
		     * @param {CertificationCampaignFiltersApiGetCampaignFilterByIdRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof CertificationCampaignFiltersApi
		     */
		    CertificationCampaignFiltersApi.prototype.getCampaignFilterById = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.CertificationCampaignFiltersApiFp)(this.configuration).getCampaignFilterById(requestParameters.filterId, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Lists all Campaign Filters. Scope can be reduced via standard V3 query params.  All Campaign Filters matching the query params
		     * @summary List Campaign Filters
		     * @param {CertificationCampaignFiltersApiListCampaignFiltersRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof CertificationCampaignFiltersApi
		     */
		    CertificationCampaignFiltersApi.prototype.listCampaignFilters = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.CertificationCampaignFiltersApiFp)(this.configuration).listCampaignFilters(requestParameters.limit, requestParameters.start, requestParameters.includeSystemFilters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Updates an existing campaign filter using the filter\'s ID.
		     * @summary Updates a Campaign Filter
		     * @param {CertificationCampaignFiltersApiUpdateCampaignFilterRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof CertificationCampaignFiltersApi
		     */
		    CertificationCampaignFiltersApi.prototype.updateCampaignFilter = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.CertificationCampaignFiltersApiFp)(this.configuration).updateCampaignFilter(requestParameters.filterId, requestParameters.campaignFilterDetails, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return CertificationCampaignFiltersApi;
		}(base_1.BaseAPI));
		exports.CertificationCampaignFiltersApi = CertificationCampaignFiltersApi;
		/**
		 * CertificationCampaignsApi - axios parameter creator
		 * @export
		 */
		var CertificationCampaignsApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * :::caution  This endpoint will run successfully for any campaigns that are **past due**.  This endpoint will return a content error if the campaign is **not past due**.  :::  Completes a certification campaign. This is provided to admins so that they can complete a certification even if all items have not been completed.  Requires roles of CERT_ADMIN and ORG_ADMIN
		         * @summary Complete a Campaign
		         * @param {string} id The campaign id
		         * @param {CampaignCompleteOptions} [campaignCompleteOptions] Optional. Default behavior is for the campaign to auto-approve upon completion, unless autoCompleteAction&#x3D;REVOKE
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        completeCampaign: function (id, campaignCompleteOptions, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('completeCampaign', 'id', id);
		                            localVarPath = "/campaigns/{id}/complete"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(campaignCompleteOptions, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Creates a new Certification Campaign with the information provided in the request body.
		         * @summary Create a campaign
		         * @param {Campaign} campaign
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createCampaign: function (campaign, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'campaign' is not null or undefined
		                            (0, common_1.assertParamExists)('createCampaign', 'campaign', campaign);
		                            localVarPath = "/campaigns";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(campaign, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Create a campaign Template based on campaign.
		         * @summary Create a Campaign Template
		         * @param {CampaignTemplate} campaignTemplate
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createCampaignTemplate: function (campaignTemplate, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'campaignTemplate' is not null or undefined
		                            (0, common_1.assertParamExists)('createCampaignTemplate', 'campaignTemplate', campaignTemplate);
		                            localVarPath = "/campaign-templates";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(campaignTemplate, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Deletes a campaign template by ID.
		         * @summary Delete a Campaign Template
		         * @param {string} id The ID of the campaign template being deleted.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteCampaignTemplate: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('deleteCampaignTemplate', 'id', id);
		                            localVarPath = "/campaign-templates/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'DELETE' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Deletes the schedule for a campaign template. Returns a 404 if there is no schedule set.
		         * @summary Deletes a Campaign Template\'s Schedule
		         * @param {string} id The ID of the campaign template whose schedule is being deleted.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteCampaignTemplateSchedule: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('deleteCampaignTemplateSchedule', 'id', id);
		                            localVarPath = "/campaign-templates/{id}/schedule"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'DELETE' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Deletes campaigns whose Ids are specified in the provided list of campaign Ids. Authorized callers must be an ORG_ADMIN or a CERT_ADMIN.
		         * @summary Deletes Campaigns
		         * @param {CampaignsDeleteRequest} campaignsDeleteRequest The ids of the campaigns to delete.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteCampaigns: function (campaignsDeleteRequest, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'campaignsDeleteRequest' is not null or undefined
		                            (0, common_1.assertParamExists)('deleteCampaigns', 'campaignsDeleteRequest', campaignsDeleteRequest);
		                            localVarPath = "/campaigns/delete";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(campaignsDeleteRequest, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Gets campaigns and returns them in a list. Can provide increased level of detail for each campaign if provided the correct query.
		         * @summary List Campaigns
		         * @param {'SLIM' | 'FULL'} [detail] Determines whether slim, or increased level of detail is provided for each campaign in the returned list. Slim is the default behavior.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **name**: *eq, sw*  **status**: *eq, in*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name, created**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getActiveCampaigns: function (detail, limit, offset, count, filters, sorters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/campaigns";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (detail !== undefined) {
		                                localVarQueryParameter['detail'] = detail;
		                            }
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Retrieves information for an existing campaign using the campaign\'s ID. Authorized callers must be a reviewer for this campaign, an ORG_ADMIN, or a CERT_ADMIN.
		         * @summary Get a campaign
		         * @param {string} id The ID of the campaign to be retrieved
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getCampaign: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getCampaign', 'id', id);
		                            localVarPath = "/campaigns/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Fetches all reports for a certification campaign by campaign ID. Requires roles of CERT_ADMIN, DASHBOARD, ORG_ADMIN and REPORT_ADMIN
		         * @summary Get Campaign Reports
		         * @param {string} id The ID of the campaign for which reports are being fetched.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getCampaignReports: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getCampaignReports', 'id', id);
		                            localVarPath = "/campaigns/{id}/reports"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Fetches configuration for campaign reports. Currently it includes only one element - identity attributes defined as custom report columns. Requires roles of CERT_ADMIN and ORG_ADMIN.
		         * @summary Get Campaign Reports Configuration
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getCampaignReportsConfig: function (axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/campaigns/reports-configuration";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Fetches a campaign template by ID.
		         * @summary Get a Campaign Template
		         * @param {string} id The desired campaign template\&#39;s ID.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getCampaignTemplate: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getCampaignTemplate', 'id', id);
		                            localVarPath = "/campaign-templates/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Gets the schedule for a campaign template. Returns a 404 if there is no schedule set.
		         * @summary Gets a Campaign Template\'s Schedule
		         * @param {string} id The ID of the campaign template whose schedule is being fetched.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getCampaignTemplateSchedule: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getCampaignTemplateSchedule', 'id', id);
		                            localVarPath = "/campaign-templates/{id}/schedule"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Lists all CampaignTemplates. Scope can be reduced via standard V3 query params.  All CampaignTemplates matching the query params
		         * @summary List Campaign Templates
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name, created, modified**
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **name**: *eq, ge, gt, in, le, lt, ne, sw*  **id**: *eq, ge, gt, in, le, lt, ne, sw*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listCampaignTemplates: function (limit, offset, count, sorters, filters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/campaign-templates";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API reassigns the specified certifications from one identity to another. A token with ORG_ADMIN or CERT_ADMIN authority is required to call this API.
		         * @summary Reassign Certifications
		         * @param {string} id The certification campaign ID
		         * @param {AdminReviewReassign} adminReviewReassign
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        move: function (id, adminReviewReassign, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('move', 'id', id);
		                            // verify required parameter 'adminReviewReassign' is not null or undefined
		                            (0, common_1.assertParamExists)('move', 'adminReviewReassign', adminReviewReassign);
		                            localVarPath = "/campaigns/{id}/reassign"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(adminReviewReassign, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Allows updating individual fields on a campaign template using the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.
		         * @summary Update a Campaign Template
		         * @param {string} id The ID of the campaign template being modified.
		         * @param {Array<JsonPatchOperation>} jsonPatchOperation A list of campaign update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.  The following fields are patchable: * name * description * deadlineDuration * campaign (all fields that are allowed during create)
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchCampaignTemplate: function (id, jsonPatchOperation, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('patchCampaignTemplate', 'id', id);
		                            // verify required parameter 'jsonPatchOperation' is not null or undefined
		                            (0, common_1.assertParamExists)('patchCampaignTemplate', 'jsonPatchOperation', jsonPatchOperation);
		                            localVarPath = "/campaign-templates/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PATCH' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json-patch+json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(jsonPatchOperation, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Overwrites configuration for campaign reports. Requires roles CERT_ADMIN and ORG_ADMIN.
		         * @summary Set Campaign Reports Configuration
		         * @param {CampaignReportsConfig} campaignReportsConfig Campaign Report Configuration
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        setCampaignReportsConfig: function (campaignReportsConfig, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'campaignReportsConfig' is not null or undefined
		                            (0, common_1.assertParamExists)('setCampaignReportsConfig', 'campaignReportsConfig', campaignReportsConfig);
		                            localVarPath = "/campaigns/reports-configuration";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PUT' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(campaignReportsConfig, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Sets the schedule for a campaign template. If a schedule already exists, it will be overwritten with the new one.
		         * @summary Sets a Campaign Template\'s Schedule
		         * @param {string} id The ID of the campaign template being scheduled.
		         * @param {Schedule} [schedule]
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        setCampaignTemplateSchedule: function (id, schedule, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('setCampaignTemplateSchedule', 'id', id);
		                            localVarPath = "/campaign-templates/{id}/schedule"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PUT' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(schedule, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Submits a job to activate the campaign with the given Id. The campaign must be staged. Requires roles of CERT_ADMIN and ORG_ADMIN
		         * @summary Activate a Campaign
		         * @param {string} id The campaign id
		         * @param {ActivateCampaignOptions} [activateCampaignOptions] Optional. If no timezone is specified, the standard UTC timezone is used (i.e. UTC+00:00). Although this can take any timezone, the intended value is the caller\&#39;s timezone. The activation time calculated from the given timezone may cause the campaign deadline time to be modified, but it will remain within the original date. The timezone must be in a valid ISO 8601 format.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        startCampaign: function (id, activateCampaignOptions, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('startCampaign', 'id', id);
		                            localVarPath = "/campaigns/{id}/activate"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(activateCampaignOptions, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Kicks off remediation scan task for a certification campaign. Requires roles of CERT_ADMIN and ORG_ADMIN
		         * @summary Run Campaign Remediation Scan
		         * @param {string} id The ID of the campaign for which remediation scan is being run.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        startCampaignRemediationScan: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('startCampaignRemediationScan', 'id', id);
		                            localVarPath = "/campaigns/{id}/run-remediation-scan"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Runs a report for a certification campaign. Requires the following roles: CERT_ADMIN, DASHBOARD, ORG_ADMIN and REPORT_ADMIN.
		         * @summary Run Campaign Report
		         * @param {string} id The ID of the campaign for which report is being run.
		         * @param {ReportType} type The type of the report to run.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        startCampaignReport: function (id, type, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('startCampaignReport', 'id', id);
		                            // verify required parameter 'type' is not null or undefined
		                            (0, common_1.assertParamExists)('startCampaignReport', 'type', type);
		                            localVarPath = "/campaigns/{id}/run-report/{type}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)))
		                                .replace("{".concat("type", "}"), encodeURIComponent(String(type)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Generates a new campaign from a campaign template. The campaign object contained in the template has special formatting applied to its name and description fields in order to determine the generated campaign\'s name/description. Placeholders in those fields are formatted with the current date and time upon generation. Placeholders consist of a percent sign followed by a letter indicating what should be inserted; for example, \"%Y\" will insert the current year; a campaign template named \"Campaign for %y\" would generate a campaign called \"Campaign for 2020\" (assuming the year at generation time is 2020). Valid placeholders are the date/time conversion suffix characters supported by [java.util.Formatter](https://docs.oracle.com/javase/8/docs/api/java/util/Formatter.html). Requires roles ORG_ADMIN.
		         * @summary Generate a Campaign from Template
		         * @param {string} id The ID of the campaign template to use for generation.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        startGenerateCampaignTemplate: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('startGenerateCampaignTemplate', 'id', id);
		                            localVarPath = "/campaign-templates/{id}/generate"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Allows updating individual fields on a campaign using the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.
		         * @summary Update a Campaign
		         * @param {string} id The ID of the campaign template being modified.
		         * @param {Array<JsonPatchOperation>} jsonPatchOperation A list of campaign update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard. The fields that can be patched differ based on the status of the campaign.  In the *STAGED* status, the following fields can be patched: * name * description * recommendationsEnabled * deadline * emailNotificationEnabled * autoRevokeAllowed  In the *ACTIVE* status, the following fields can be patched: * deadline
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateCampaign: function (id, jsonPatchOperation, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('updateCampaign', 'id', id);
		                            // verify required parameter 'jsonPatchOperation' is not null or undefined
		                            (0, common_1.assertParamExists)('updateCampaign', 'jsonPatchOperation', jsonPatchOperation);
		                            localVarPath = "/campaigns/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PATCH' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json-patch+json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(jsonPatchOperation, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.CertificationCampaignsApiAxiosParamCreator = CertificationCampaignsApiAxiosParamCreator;
		/**
		 * CertificationCampaignsApi - functional programming interface
		 * @export
		 */
		var CertificationCampaignsApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.CertificationCampaignsApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * :::caution  This endpoint will run successfully for any campaigns that are **past due**.  This endpoint will return a content error if the campaign is **not past due**.  :::  Completes a certification campaign. This is provided to admins so that they can complete a certification even if all items have not been completed.  Requires roles of CERT_ADMIN and ORG_ADMIN
		         * @summary Complete a Campaign
		         * @param {string} id The campaign id
		         * @param {CampaignCompleteOptions} [campaignCompleteOptions] Optional. Default behavior is for the campaign to auto-approve upon completion, unless autoCompleteAction&#x3D;REVOKE
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        completeCampaign: function (id, campaignCompleteOptions, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.completeCampaign(id, campaignCompleteOptions, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Creates a new Certification Campaign with the information provided in the request body.
		         * @summary Create a campaign
		         * @param {Campaign} campaign
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createCampaign: function (campaign, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.createCampaign(campaign, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Create a campaign Template based on campaign.
		         * @summary Create a Campaign Template
		         * @param {CampaignTemplate} campaignTemplate
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createCampaignTemplate: function (campaignTemplate, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.createCampaignTemplate(campaignTemplate, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Deletes a campaign template by ID.
		         * @summary Delete a Campaign Template
		         * @param {string} id The ID of the campaign template being deleted.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteCampaignTemplate: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.deleteCampaignTemplate(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Deletes the schedule for a campaign template. Returns a 404 if there is no schedule set.
		         * @summary Deletes a Campaign Template\'s Schedule
		         * @param {string} id The ID of the campaign template whose schedule is being deleted.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteCampaignTemplateSchedule: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.deleteCampaignTemplateSchedule(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Deletes campaigns whose Ids are specified in the provided list of campaign Ids. Authorized callers must be an ORG_ADMIN or a CERT_ADMIN.
		         * @summary Deletes Campaigns
		         * @param {CampaignsDeleteRequest} campaignsDeleteRequest The ids of the campaigns to delete.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteCampaigns: function (campaignsDeleteRequest, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.deleteCampaigns(campaignsDeleteRequest, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Gets campaigns and returns them in a list. Can provide increased level of detail for each campaign if provided the correct query.
		         * @summary List Campaigns
		         * @param {'SLIM' | 'FULL'} [detail] Determines whether slim, or increased level of detail is provided for each campaign in the returned list. Slim is the default behavior.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **name**: *eq, sw*  **status**: *eq, in*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name, created**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getActiveCampaigns: function (detail, limit, offset, count, filters, sorters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getActiveCampaigns(detail, limit, offset, count, filters, sorters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Retrieves information for an existing campaign using the campaign\'s ID. Authorized callers must be a reviewer for this campaign, an ORG_ADMIN, or a CERT_ADMIN.
		         * @summary Get a campaign
		         * @param {string} id The ID of the campaign to be retrieved
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getCampaign: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getCampaign(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Fetches all reports for a certification campaign by campaign ID. Requires roles of CERT_ADMIN, DASHBOARD, ORG_ADMIN and REPORT_ADMIN
		         * @summary Get Campaign Reports
		         * @param {string} id The ID of the campaign for which reports are being fetched.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getCampaignReports: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getCampaignReports(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Fetches configuration for campaign reports. Currently it includes only one element - identity attributes defined as custom report columns. Requires roles of CERT_ADMIN and ORG_ADMIN.
		         * @summary Get Campaign Reports Configuration
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getCampaignReportsConfig: function (axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getCampaignReportsConfig(axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Fetches a campaign template by ID.
		         * @summary Get a Campaign Template
		         * @param {string} id The desired campaign template\&#39;s ID.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getCampaignTemplate: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getCampaignTemplate(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Gets the schedule for a campaign template. Returns a 404 if there is no schedule set.
		         * @summary Gets a Campaign Template\'s Schedule
		         * @param {string} id The ID of the campaign template whose schedule is being fetched.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getCampaignTemplateSchedule: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getCampaignTemplateSchedule(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Lists all CampaignTemplates. Scope can be reduced via standard V3 query params.  All CampaignTemplates matching the query params
		         * @summary List Campaign Templates
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name, created, modified**
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **name**: *eq, ge, gt, in, le, lt, ne, sw*  **id**: *eq, ge, gt, in, le, lt, ne, sw*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listCampaignTemplates: function (limit, offset, count, sorters, filters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listCampaignTemplates(limit, offset, count, sorters, filters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API reassigns the specified certifications from one identity to another. A token with ORG_ADMIN or CERT_ADMIN authority is required to call this API.
		         * @summary Reassign Certifications
		         * @param {string} id The certification campaign ID
		         * @param {AdminReviewReassign} adminReviewReassign
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        move: function (id, adminReviewReassign, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.move(id, adminReviewReassign, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Allows updating individual fields on a campaign template using the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.
		         * @summary Update a Campaign Template
		         * @param {string} id The ID of the campaign template being modified.
		         * @param {Array<JsonPatchOperation>} jsonPatchOperation A list of campaign update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.  The following fields are patchable: * name * description * deadlineDuration * campaign (all fields that are allowed during create)
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchCampaignTemplate: function (id, jsonPatchOperation, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.patchCampaignTemplate(id, jsonPatchOperation, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Overwrites configuration for campaign reports. Requires roles CERT_ADMIN and ORG_ADMIN.
		         * @summary Set Campaign Reports Configuration
		         * @param {CampaignReportsConfig} campaignReportsConfig Campaign Report Configuration
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        setCampaignReportsConfig: function (campaignReportsConfig, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.setCampaignReportsConfig(campaignReportsConfig, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Sets the schedule for a campaign template. If a schedule already exists, it will be overwritten with the new one.
		         * @summary Sets a Campaign Template\'s Schedule
		         * @param {string} id The ID of the campaign template being scheduled.
		         * @param {Schedule} [schedule]
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        setCampaignTemplateSchedule: function (id, schedule, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.setCampaignTemplateSchedule(id, schedule, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Submits a job to activate the campaign with the given Id. The campaign must be staged. Requires roles of CERT_ADMIN and ORG_ADMIN
		         * @summary Activate a Campaign
		         * @param {string} id The campaign id
		         * @param {ActivateCampaignOptions} [activateCampaignOptions] Optional. If no timezone is specified, the standard UTC timezone is used (i.e. UTC+00:00). Although this can take any timezone, the intended value is the caller\&#39;s timezone. The activation time calculated from the given timezone may cause the campaign deadline time to be modified, but it will remain within the original date. The timezone must be in a valid ISO 8601 format.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        startCampaign: function (id, activateCampaignOptions, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.startCampaign(id, activateCampaignOptions, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Kicks off remediation scan task for a certification campaign. Requires roles of CERT_ADMIN and ORG_ADMIN
		         * @summary Run Campaign Remediation Scan
		         * @param {string} id The ID of the campaign for which remediation scan is being run.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        startCampaignRemediationScan: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.startCampaignRemediationScan(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Runs a report for a certification campaign. Requires the following roles: CERT_ADMIN, DASHBOARD, ORG_ADMIN and REPORT_ADMIN.
		         * @summary Run Campaign Report
		         * @param {string} id The ID of the campaign for which report is being run.
		         * @param {ReportType} type The type of the report to run.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        startCampaignReport: function (id, type, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.startCampaignReport(id, type, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Generates a new campaign from a campaign template. The campaign object contained in the template has special formatting applied to its name and description fields in order to determine the generated campaign\'s name/description. Placeholders in those fields are formatted with the current date and time upon generation. Placeholders consist of a percent sign followed by a letter indicating what should be inserted; for example, \"%Y\" will insert the current year; a campaign template named \"Campaign for %y\" would generate a campaign called \"Campaign for 2020\" (assuming the year at generation time is 2020). Valid placeholders are the date/time conversion suffix characters supported by [java.util.Formatter](https://docs.oracle.com/javase/8/docs/api/java/util/Formatter.html). Requires roles ORG_ADMIN.
		         * @summary Generate a Campaign from Template
		         * @param {string} id The ID of the campaign template to use for generation.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        startGenerateCampaignTemplate: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.startGenerateCampaignTemplate(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Allows updating individual fields on a campaign using the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.
		         * @summary Update a Campaign
		         * @param {string} id The ID of the campaign template being modified.
		         * @param {Array<JsonPatchOperation>} jsonPatchOperation A list of campaign update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard. The fields that can be patched differ based on the status of the campaign.  In the *STAGED* status, the following fields can be patched: * name * description * recommendationsEnabled * deadline * emailNotificationEnabled * autoRevokeAllowed  In the *ACTIVE* status, the following fields can be patched: * deadline
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateCampaign: function (id, jsonPatchOperation, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.updateCampaign(id, jsonPatchOperation, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.CertificationCampaignsApiFp = CertificationCampaignsApiFp;
		/**
		 * CertificationCampaignsApi - factory interface
		 * @export
		 */
		var CertificationCampaignsApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.CertificationCampaignsApiFp)(configuration);
		    return {
		        /**
		         * :::caution  This endpoint will run successfully for any campaigns that are **past due**.  This endpoint will return a content error if the campaign is **not past due**.  :::  Completes a certification campaign. This is provided to admins so that they can complete a certification even if all items have not been completed.  Requires roles of CERT_ADMIN and ORG_ADMIN
		         * @summary Complete a Campaign
		         * @param {string} id The campaign id
		         * @param {CampaignCompleteOptions} [campaignCompleteOptions] Optional. Default behavior is for the campaign to auto-approve upon completion, unless autoCompleteAction&#x3D;REVOKE
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        completeCampaign: function (id, campaignCompleteOptions, axiosOptions) {
		            return localVarFp.completeCampaign(id, campaignCompleteOptions, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Creates a new Certification Campaign with the information provided in the request body.
		         * @summary Create a campaign
		         * @param {Campaign} campaign
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createCampaign: function (campaign, axiosOptions) {
		            return localVarFp.createCampaign(campaign, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Create a campaign Template based on campaign.
		         * @summary Create a Campaign Template
		         * @param {CampaignTemplate} campaignTemplate
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createCampaignTemplate: function (campaignTemplate, axiosOptions) {
		            return localVarFp.createCampaignTemplate(campaignTemplate, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Deletes a campaign template by ID.
		         * @summary Delete a Campaign Template
		         * @param {string} id The ID of the campaign template being deleted.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteCampaignTemplate: function (id, axiosOptions) {
		            return localVarFp.deleteCampaignTemplate(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Deletes the schedule for a campaign template. Returns a 404 if there is no schedule set.
		         * @summary Deletes a Campaign Template\'s Schedule
		         * @param {string} id The ID of the campaign template whose schedule is being deleted.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteCampaignTemplateSchedule: function (id, axiosOptions) {
		            return localVarFp.deleteCampaignTemplateSchedule(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Deletes campaigns whose Ids are specified in the provided list of campaign Ids. Authorized callers must be an ORG_ADMIN or a CERT_ADMIN.
		         * @summary Deletes Campaigns
		         * @param {CampaignsDeleteRequest} campaignsDeleteRequest The ids of the campaigns to delete.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteCampaigns: function (campaignsDeleteRequest, axiosOptions) {
		            return localVarFp.deleteCampaigns(campaignsDeleteRequest, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Gets campaigns and returns them in a list. Can provide increased level of detail for each campaign if provided the correct query.
		         * @summary List Campaigns
		         * @param {'SLIM' | 'FULL'} [detail] Determines whether slim, or increased level of detail is provided for each campaign in the returned list. Slim is the default behavior.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **name**: *eq, sw*  **status**: *eq, in*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name, created**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getActiveCampaigns: function (detail, limit, offset, count, filters, sorters, axiosOptions) {
		            return localVarFp.getActiveCampaigns(detail, limit, offset, count, filters, sorters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Retrieves information for an existing campaign using the campaign\'s ID. Authorized callers must be a reviewer for this campaign, an ORG_ADMIN, or a CERT_ADMIN.
		         * @summary Get a campaign
		         * @param {string} id The ID of the campaign to be retrieved
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getCampaign: function (id, axiosOptions) {
		            return localVarFp.getCampaign(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Fetches all reports for a certification campaign by campaign ID. Requires roles of CERT_ADMIN, DASHBOARD, ORG_ADMIN and REPORT_ADMIN
		         * @summary Get Campaign Reports
		         * @param {string} id The ID of the campaign for which reports are being fetched.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getCampaignReports: function (id, axiosOptions) {
		            return localVarFp.getCampaignReports(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Fetches configuration for campaign reports. Currently it includes only one element - identity attributes defined as custom report columns. Requires roles of CERT_ADMIN and ORG_ADMIN.
		         * @summary Get Campaign Reports Configuration
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getCampaignReportsConfig: function (axiosOptions) {
		            return localVarFp.getCampaignReportsConfig(axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Fetches a campaign template by ID.
		         * @summary Get a Campaign Template
		         * @param {string} id The desired campaign template\&#39;s ID.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getCampaignTemplate: function (id, axiosOptions) {
		            return localVarFp.getCampaignTemplate(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Gets the schedule for a campaign template. Returns a 404 if there is no schedule set.
		         * @summary Gets a Campaign Template\'s Schedule
		         * @param {string} id The ID of the campaign template whose schedule is being fetched.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getCampaignTemplateSchedule: function (id, axiosOptions) {
		            return localVarFp.getCampaignTemplateSchedule(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Lists all CampaignTemplates. Scope can be reduced via standard V3 query params.  All CampaignTemplates matching the query params
		         * @summary List Campaign Templates
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name, created, modified**
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **name**: *eq, ge, gt, in, le, lt, ne, sw*  **id**: *eq, ge, gt, in, le, lt, ne, sw*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listCampaignTemplates: function (limit, offset, count, sorters, filters, axiosOptions) {
		            return localVarFp.listCampaignTemplates(limit, offset, count, sorters, filters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API reassigns the specified certifications from one identity to another. A token with ORG_ADMIN or CERT_ADMIN authority is required to call this API.
		         * @summary Reassign Certifications
		         * @param {string} id The certification campaign ID
		         * @param {AdminReviewReassign} adminReviewReassign
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        move: function (id, adminReviewReassign, axiosOptions) {
		            return localVarFp.move(id, adminReviewReassign, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Allows updating individual fields on a campaign template using the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.
		         * @summary Update a Campaign Template
		         * @param {string} id The ID of the campaign template being modified.
		         * @param {Array<JsonPatchOperation>} jsonPatchOperation A list of campaign update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.  The following fields are patchable: * name * description * deadlineDuration * campaign (all fields that are allowed during create)
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchCampaignTemplate: function (id, jsonPatchOperation, axiosOptions) {
		            return localVarFp.patchCampaignTemplate(id, jsonPatchOperation, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Overwrites configuration for campaign reports. Requires roles CERT_ADMIN and ORG_ADMIN.
		         * @summary Set Campaign Reports Configuration
		         * @param {CampaignReportsConfig} campaignReportsConfig Campaign Report Configuration
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        setCampaignReportsConfig: function (campaignReportsConfig, axiosOptions) {
		            return localVarFp.setCampaignReportsConfig(campaignReportsConfig, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Sets the schedule for a campaign template. If a schedule already exists, it will be overwritten with the new one.
		         * @summary Sets a Campaign Template\'s Schedule
		         * @param {string} id The ID of the campaign template being scheduled.
		         * @param {Schedule} [schedule]
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        setCampaignTemplateSchedule: function (id, schedule, axiosOptions) {
		            return localVarFp.setCampaignTemplateSchedule(id, schedule, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Submits a job to activate the campaign with the given Id. The campaign must be staged. Requires roles of CERT_ADMIN and ORG_ADMIN
		         * @summary Activate a Campaign
		         * @param {string} id The campaign id
		         * @param {ActivateCampaignOptions} [activateCampaignOptions] Optional. If no timezone is specified, the standard UTC timezone is used (i.e. UTC+00:00). Although this can take any timezone, the intended value is the caller\&#39;s timezone. The activation time calculated from the given timezone may cause the campaign deadline time to be modified, but it will remain within the original date. The timezone must be in a valid ISO 8601 format.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        startCampaign: function (id, activateCampaignOptions, axiosOptions) {
		            return localVarFp.startCampaign(id, activateCampaignOptions, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Kicks off remediation scan task for a certification campaign. Requires roles of CERT_ADMIN and ORG_ADMIN
		         * @summary Run Campaign Remediation Scan
		         * @param {string} id The ID of the campaign for which remediation scan is being run.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        startCampaignRemediationScan: function (id, axiosOptions) {
		            return localVarFp.startCampaignRemediationScan(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Runs a report for a certification campaign. Requires the following roles: CERT_ADMIN, DASHBOARD, ORG_ADMIN and REPORT_ADMIN.
		         * @summary Run Campaign Report
		         * @param {string} id The ID of the campaign for which report is being run.
		         * @param {ReportType} type The type of the report to run.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        startCampaignReport: function (id, type, axiosOptions) {
		            return localVarFp.startCampaignReport(id, type, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Generates a new campaign from a campaign template. The campaign object contained in the template has special formatting applied to its name and description fields in order to determine the generated campaign\'s name/description. Placeholders in those fields are formatted with the current date and time upon generation. Placeholders consist of a percent sign followed by a letter indicating what should be inserted; for example, \"%Y\" will insert the current year; a campaign template named \"Campaign for %y\" would generate a campaign called \"Campaign for 2020\" (assuming the year at generation time is 2020). Valid placeholders are the date/time conversion suffix characters supported by [java.util.Formatter](https://docs.oracle.com/javase/8/docs/api/java/util/Formatter.html). Requires roles ORG_ADMIN.
		         * @summary Generate a Campaign from Template
		         * @param {string} id The ID of the campaign template to use for generation.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        startGenerateCampaignTemplate: function (id, axiosOptions) {
		            return localVarFp.startGenerateCampaignTemplate(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Allows updating individual fields on a campaign using the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.
		         * @summary Update a Campaign
		         * @param {string} id The ID of the campaign template being modified.
		         * @param {Array<JsonPatchOperation>} jsonPatchOperation A list of campaign update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard. The fields that can be patched differ based on the status of the campaign.  In the *STAGED* status, the following fields can be patched: * name * description * recommendationsEnabled * deadline * emailNotificationEnabled * autoRevokeAllowed  In the *ACTIVE* status, the following fields can be patched: * deadline
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateCampaign: function (id, jsonPatchOperation, axiosOptions) {
		            return localVarFp.updateCampaign(id, jsonPatchOperation, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.CertificationCampaignsApiFactory = CertificationCampaignsApiFactory;
		/**
		 * CertificationCampaignsApi - object-oriented interface
		 * @export
		 * @class CertificationCampaignsApi
		 * @extends {BaseAPI}
		 */
		var CertificationCampaignsApi = /** @class */ (function (_super) {
		    __extends(CertificationCampaignsApi, _super);
		    function CertificationCampaignsApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * :::caution  This endpoint will run successfully for any campaigns that are **past due**.  This endpoint will return a content error if the campaign is **not past due**.  :::  Completes a certification campaign. This is provided to admins so that they can complete a certification even if all items have not been completed.  Requires roles of CERT_ADMIN and ORG_ADMIN
		     * @summary Complete a Campaign
		     * @param {CertificationCampaignsApiCompleteCampaignRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof CertificationCampaignsApi
		     */
		    CertificationCampaignsApi.prototype.completeCampaign = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.CertificationCampaignsApiFp)(this.configuration).completeCampaign(requestParameters.id, requestParameters.campaignCompleteOptions, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Creates a new Certification Campaign with the information provided in the request body.
		     * @summary Create a campaign
		     * @param {CertificationCampaignsApiCreateCampaignRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof CertificationCampaignsApi
		     */
		    CertificationCampaignsApi.prototype.createCampaign = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.CertificationCampaignsApiFp)(this.configuration).createCampaign(requestParameters.campaign, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Create a campaign Template based on campaign.
		     * @summary Create a Campaign Template
		     * @param {CertificationCampaignsApiCreateCampaignTemplateRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof CertificationCampaignsApi
		     */
		    CertificationCampaignsApi.prototype.createCampaignTemplate = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.CertificationCampaignsApiFp)(this.configuration).createCampaignTemplate(requestParameters.campaignTemplate, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Deletes a campaign template by ID.
		     * @summary Delete a Campaign Template
		     * @param {CertificationCampaignsApiDeleteCampaignTemplateRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof CertificationCampaignsApi
		     */
		    CertificationCampaignsApi.prototype.deleteCampaignTemplate = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.CertificationCampaignsApiFp)(this.configuration).deleteCampaignTemplate(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Deletes the schedule for a campaign template. Returns a 404 if there is no schedule set.
		     * @summary Deletes a Campaign Template\'s Schedule
		     * @param {CertificationCampaignsApiDeleteCampaignTemplateScheduleRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof CertificationCampaignsApi
		     */
		    CertificationCampaignsApi.prototype.deleteCampaignTemplateSchedule = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.CertificationCampaignsApiFp)(this.configuration).deleteCampaignTemplateSchedule(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Deletes campaigns whose Ids are specified in the provided list of campaign Ids. Authorized callers must be an ORG_ADMIN or a CERT_ADMIN.
		     * @summary Deletes Campaigns
		     * @param {CertificationCampaignsApiDeleteCampaignsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof CertificationCampaignsApi
		     */
		    CertificationCampaignsApi.prototype.deleteCampaigns = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.CertificationCampaignsApiFp)(this.configuration).deleteCampaigns(requestParameters.campaignsDeleteRequest, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Gets campaigns and returns them in a list. Can provide increased level of detail for each campaign if provided the correct query.
		     * @summary List Campaigns
		     * @param {CertificationCampaignsApiGetActiveCampaignsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof CertificationCampaignsApi
		     */
		    CertificationCampaignsApi.prototype.getActiveCampaigns = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.CertificationCampaignsApiFp)(this.configuration).getActiveCampaigns(requestParameters.detail, requestParameters.limit, requestParameters.offset, requestParameters.count, requestParameters.filters, requestParameters.sorters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Retrieves information for an existing campaign using the campaign\'s ID. Authorized callers must be a reviewer for this campaign, an ORG_ADMIN, or a CERT_ADMIN.
		     * @summary Get a campaign
		     * @param {CertificationCampaignsApiGetCampaignRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof CertificationCampaignsApi
		     */
		    CertificationCampaignsApi.prototype.getCampaign = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.CertificationCampaignsApiFp)(this.configuration).getCampaign(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Fetches all reports for a certification campaign by campaign ID. Requires roles of CERT_ADMIN, DASHBOARD, ORG_ADMIN and REPORT_ADMIN
		     * @summary Get Campaign Reports
		     * @param {CertificationCampaignsApiGetCampaignReportsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof CertificationCampaignsApi
		     */
		    CertificationCampaignsApi.prototype.getCampaignReports = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.CertificationCampaignsApiFp)(this.configuration).getCampaignReports(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Fetches configuration for campaign reports. Currently it includes only one element - identity attributes defined as custom report columns. Requires roles of CERT_ADMIN and ORG_ADMIN.
		     * @summary Get Campaign Reports Configuration
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof CertificationCampaignsApi
		     */
		    CertificationCampaignsApi.prototype.getCampaignReportsConfig = function (axiosOptions) {
		        var _this = this;
		        return (0, exports.CertificationCampaignsApiFp)(this.configuration).getCampaignReportsConfig(axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Fetches a campaign template by ID.
		     * @summary Get a Campaign Template
		     * @param {CertificationCampaignsApiGetCampaignTemplateRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof CertificationCampaignsApi
		     */
		    CertificationCampaignsApi.prototype.getCampaignTemplate = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.CertificationCampaignsApiFp)(this.configuration).getCampaignTemplate(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Gets the schedule for a campaign template. Returns a 404 if there is no schedule set.
		     * @summary Gets a Campaign Template\'s Schedule
		     * @param {CertificationCampaignsApiGetCampaignTemplateScheduleRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof CertificationCampaignsApi
		     */
		    CertificationCampaignsApi.prototype.getCampaignTemplateSchedule = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.CertificationCampaignsApiFp)(this.configuration).getCampaignTemplateSchedule(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Lists all CampaignTemplates. Scope can be reduced via standard V3 query params.  All CampaignTemplates matching the query params
		     * @summary List Campaign Templates
		     * @param {CertificationCampaignsApiListCampaignTemplatesRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof CertificationCampaignsApi
		     */
		    CertificationCampaignsApi.prototype.listCampaignTemplates = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.CertificationCampaignsApiFp)(this.configuration).listCampaignTemplates(requestParameters.limit, requestParameters.offset, requestParameters.count, requestParameters.sorters, requestParameters.filters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API reassigns the specified certifications from one identity to another. A token with ORG_ADMIN or CERT_ADMIN authority is required to call this API.
		     * @summary Reassign Certifications
		     * @param {CertificationCampaignsApiMoveRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof CertificationCampaignsApi
		     */
		    CertificationCampaignsApi.prototype.move = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.CertificationCampaignsApiFp)(this.configuration).move(requestParameters.id, requestParameters.adminReviewReassign, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Allows updating individual fields on a campaign template using the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.
		     * @summary Update a Campaign Template
		     * @param {CertificationCampaignsApiPatchCampaignTemplateRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof CertificationCampaignsApi
		     */
		    CertificationCampaignsApi.prototype.patchCampaignTemplate = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.CertificationCampaignsApiFp)(this.configuration).patchCampaignTemplate(requestParameters.id, requestParameters.jsonPatchOperation, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Overwrites configuration for campaign reports. Requires roles CERT_ADMIN and ORG_ADMIN.
		     * @summary Set Campaign Reports Configuration
		     * @param {CertificationCampaignsApiSetCampaignReportsConfigRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof CertificationCampaignsApi
		     */
		    CertificationCampaignsApi.prototype.setCampaignReportsConfig = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.CertificationCampaignsApiFp)(this.configuration).setCampaignReportsConfig(requestParameters.campaignReportsConfig, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Sets the schedule for a campaign template. If a schedule already exists, it will be overwritten with the new one.
		     * @summary Sets a Campaign Template\'s Schedule
		     * @param {CertificationCampaignsApiSetCampaignTemplateScheduleRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof CertificationCampaignsApi
		     */
		    CertificationCampaignsApi.prototype.setCampaignTemplateSchedule = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.CertificationCampaignsApiFp)(this.configuration).setCampaignTemplateSchedule(requestParameters.id, requestParameters.schedule, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Submits a job to activate the campaign with the given Id. The campaign must be staged. Requires roles of CERT_ADMIN and ORG_ADMIN
		     * @summary Activate a Campaign
		     * @param {CertificationCampaignsApiStartCampaignRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof CertificationCampaignsApi
		     */
		    CertificationCampaignsApi.prototype.startCampaign = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.CertificationCampaignsApiFp)(this.configuration).startCampaign(requestParameters.id, requestParameters.activateCampaignOptions, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Kicks off remediation scan task for a certification campaign. Requires roles of CERT_ADMIN and ORG_ADMIN
		     * @summary Run Campaign Remediation Scan
		     * @param {CertificationCampaignsApiStartCampaignRemediationScanRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof CertificationCampaignsApi
		     */
		    CertificationCampaignsApi.prototype.startCampaignRemediationScan = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.CertificationCampaignsApiFp)(this.configuration).startCampaignRemediationScan(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Runs a report for a certification campaign. Requires the following roles: CERT_ADMIN, DASHBOARD, ORG_ADMIN and REPORT_ADMIN.
		     * @summary Run Campaign Report
		     * @param {CertificationCampaignsApiStartCampaignReportRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof CertificationCampaignsApi
		     */
		    CertificationCampaignsApi.prototype.startCampaignReport = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.CertificationCampaignsApiFp)(this.configuration).startCampaignReport(requestParameters.id, requestParameters.type, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Generates a new campaign from a campaign template. The campaign object contained in the template has special formatting applied to its name and description fields in order to determine the generated campaign\'s name/description. Placeholders in those fields are formatted with the current date and time upon generation. Placeholders consist of a percent sign followed by a letter indicating what should be inserted; for example, \"%Y\" will insert the current year; a campaign template named \"Campaign for %y\" would generate a campaign called \"Campaign for 2020\" (assuming the year at generation time is 2020). Valid placeholders are the date/time conversion suffix characters supported by [java.util.Formatter](https://docs.oracle.com/javase/8/docs/api/java/util/Formatter.html). Requires roles ORG_ADMIN.
		     * @summary Generate a Campaign from Template
		     * @param {CertificationCampaignsApiStartGenerateCampaignTemplateRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof CertificationCampaignsApi
		     */
		    CertificationCampaignsApi.prototype.startGenerateCampaignTemplate = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.CertificationCampaignsApiFp)(this.configuration).startGenerateCampaignTemplate(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Allows updating individual fields on a campaign using the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.
		     * @summary Update a Campaign
		     * @param {CertificationCampaignsApiUpdateCampaignRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof CertificationCampaignsApi
		     */
		    CertificationCampaignsApi.prototype.updateCampaign = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.CertificationCampaignsApiFp)(this.configuration).updateCampaign(requestParameters.id, requestParameters.jsonPatchOperation, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return CertificationCampaignsApi;
		}(base_1.BaseAPI));
		exports.CertificationCampaignsApi = CertificationCampaignsApi;
		/**
		 * CertificationSummariesApi - axios parameter creator
		 * @export
		 */
		var CertificationSummariesApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * This API returns a list of access summaries for the specified identity campaign certification and type. A token with ORG_ADMIN or CERT_ADMIN authority is required to call this API. Reviewers for this certification can also call this API.
		         * @summary Access Summaries
		         * @param {string} id The identity campaign certification ID
		         * @param {'ROLE' | 'ACCESS_PROFILE' | 'ENTITLEMENT'} type The type of access review item to retrieve summaries for
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **completed**: *eq, ne*  **access.id**: *eq, in*  **access.name**: *eq, sw*  **entitlement.sourceName**: *eq, sw*  **accessProfile.sourceName**: *eq, sw*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **access.name**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getIdentityAccessSummaries: function (id, type, limit, offset, count, filters, sorters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getIdentityAccessSummaries', 'id', id);
		                            // verify required parameter 'type' is not null or undefined
		                            (0, common_1.assertParamExists)('getIdentityAccessSummaries', 'type', type);
		                            localVarPath = "/certifications/{id}/access-summaries/{type}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)))
		                                .replace("{".concat("type", "}"), encodeURIComponent(String(type)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns a summary of the decisions made on an identity campaign certification. The decisions are summarized by type. A token with ORG_ADMIN or CERT_ADMIN authority is required to call this API. Reviewers for this certification can also call this API.
		         * @summary Summary of Certification Decisions
		         * @param {string} id The certification ID
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **identitySummary.id**: *eq, in*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getIdentityDecisionSummary: function (id, filters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getIdentityDecisionSummary', 'id', id);
		                            localVarPath = "/certifications/{id}/decision-summary"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns a list of the identity summaries for a specific identity campaign certification. A token with ORG_ADMIN or CERT_ADMIN authority is required to call this API. Reviewers for this certification can also call this API.
		         * @summary Identity Summaries for Campaign Certification
		         * @param {string} id The identity campaign certification ID
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **completed**: *eq, ne*  **name**: *eq, sw*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getIdentitySummaries: function (id, limit, offset, count, filters, sorters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getIdentitySummaries', 'id', id);
		                            localVarPath = "/certifications/{id}/identity-summaries"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns the summary for an identity on a specified identity campaign certification. A token with ORG_ADMIN or CERT_ADMIN authority is required to call this API. Reviewers for this certification can also call this API.
		         * @summary Summary for Identity
		         * @param {string} id The identity campaign certification ID
		         * @param {string} identitySummaryId The identity summary ID
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getIdentitySummary: function (id, identitySummaryId, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getIdentitySummary', 'id', id);
		                            // verify required parameter 'identitySummaryId' is not null or undefined
		                            (0, common_1.assertParamExists)('getIdentitySummary', 'identitySummaryId', identitySummaryId);
		                            localVarPath = "/certifications/{id}/identity-summaries/{identitySummaryId}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)))
		                                .replace("{".concat("identitySummaryId", "}"), encodeURIComponent(String(identitySummaryId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.CertificationSummariesApiAxiosParamCreator = CertificationSummariesApiAxiosParamCreator;
		/**
		 * CertificationSummariesApi - functional programming interface
		 * @export
		 */
		var CertificationSummariesApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.CertificationSummariesApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * This API returns a list of access summaries for the specified identity campaign certification and type. A token with ORG_ADMIN or CERT_ADMIN authority is required to call this API. Reviewers for this certification can also call this API.
		         * @summary Access Summaries
		         * @param {string} id The identity campaign certification ID
		         * @param {'ROLE' | 'ACCESS_PROFILE' | 'ENTITLEMENT'} type The type of access review item to retrieve summaries for
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **completed**: *eq, ne*  **access.id**: *eq, in*  **access.name**: *eq, sw*  **entitlement.sourceName**: *eq, sw*  **accessProfile.sourceName**: *eq, sw*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **access.name**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getIdentityAccessSummaries: function (id, type, limit, offset, count, filters, sorters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getIdentityAccessSummaries(id, type, limit, offset, count, filters, sorters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns a summary of the decisions made on an identity campaign certification. The decisions are summarized by type. A token with ORG_ADMIN or CERT_ADMIN authority is required to call this API. Reviewers for this certification can also call this API.
		         * @summary Summary of Certification Decisions
		         * @param {string} id The certification ID
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **identitySummary.id**: *eq, in*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getIdentityDecisionSummary: function (id, filters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getIdentityDecisionSummary(id, filters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns a list of the identity summaries for a specific identity campaign certification. A token with ORG_ADMIN or CERT_ADMIN authority is required to call this API. Reviewers for this certification can also call this API.
		         * @summary Identity Summaries for Campaign Certification
		         * @param {string} id The identity campaign certification ID
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **completed**: *eq, ne*  **name**: *eq, sw*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getIdentitySummaries: function (id, limit, offset, count, filters, sorters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getIdentitySummaries(id, limit, offset, count, filters, sorters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns the summary for an identity on a specified identity campaign certification. A token with ORG_ADMIN or CERT_ADMIN authority is required to call this API. Reviewers for this certification can also call this API.
		         * @summary Summary for Identity
		         * @param {string} id The identity campaign certification ID
		         * @param {string} identitySummaryId The identity summary ID
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getIdentitySummary: function (id, identitySummaryId, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getIdentitySummary(id, identitySummaryId, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.CertificationSummariesApiFp = CertificationSummariesApiFp;
		/**
		 * CertificationSummariesApi - factory interface
		 * @export
		 */
		var CertificationSummariesApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.CertificationSummariesApiFp)(configuration);
		    return {
		        /**
		         * This API returns a list of access summaries for the specified identity campaign certification and type. A token with ORG_ADMIN or CERT_ADMIN authority is required to call this API. Reviewers for this certification can also call this API.
		         * @summary Access Summaries
		         * @param {string} id The identity campaign certification ID
		         * @param {'ROLE' | 'ACCESS_PROFILE' | 'ENTITLEMENT'} type The type of access review item to retrieve summaries for
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **completed**: *eq, ne*  **access.id**: *eq, in*  **access.name**: *eq, sw*  **entitlement.sourceName**: *eq, sw*  **accessProfile.sourceName**: *eq, sw*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **access.name**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getIdentityAccessSummaries: function (id, type, limit, offset, count, filters, sorters, axiosOptions) {
		            return localVarFp.getIdentityAccessSummaries(id, type, limit, offset, count, filters, sorters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API returns a summary of the decisions made on an identity campaign certification. The decisions are summarized by type. A token with ORG_ADMIN or CERT_ADMIN authority is required to call this API. Reviewers for this certification can also call this API.
		         * @summary Summary of Certification Decisions
		         * @param {string} id The certification ID
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **identitySummary.id**: *eq, in*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getIdentityDecisionSummary: function (id, filters, axiosOptions) {
		            return localVarFp.getIdentityDecisionSummary(id, filters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API returns a list of the identity summaries for a specific identity campaign certification. A token with ORG_ADMIN or CERT_ADMIN authority is required to call this API. Reviewers for this certification can also call this API.
		         * @summary Identity Summaries for Campaign Certification
		         * @param {string} id The identity campaign certification ID
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **completed**: *eq, ne*  **name**: *eq, sw*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getIdentitySummaries: function (id, limit, offset, count, filters, sorters, axiosOptions) {
		            return localVarFp.getIdentitySummaries(id, limit, offset, count, filters, sorters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API returns the summary for an identity on a specified identity campaign certification. A token with ORG_ADMIN or CERT_ADMIN authority is required to call this API. Reviewers for this certification can also call this API.
		         * @summary Summary for Identity
		         * @param {string} id The identity campaign certification ID
		         * @param {string} identitySummaryId The identity summary ID
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getIdentitySummary: function (id, identitySummaryId, axiosOptions) {
		            return localVarFp.getIdentitySummary(id, identitySummaryId, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.CertificationSummariesApiFactory = CertificationSummariesApiFactory;
		/**
		 * CertificationSummariesApi - object-oriented interface
		 * @export
		 * @class CertificationSummariesApi
		 * @extends {BaseAPI}
		 */
		var CertificationSummariesApi = /** @class */ (function (_super) {
		    __extends(CertificationSummariesApi, _super);
		    function CertificationSummariesApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * This API returns a list of access summaries for the specified identity campaign certification and type. A token with ORG_ADMIN or CERT_ADMIN authority is required to call this API. Reviewers for this certification can also call this API.
		     * @summary Access Summaries
		     * @param {CertificationSummariesApiGetIdentityAccessSummariesRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof CertificationSummariesApi
		     */
		    CertificationSummariesApi.prototype.getIdentityAccessSummaries = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.CertificationSummariesApiFp)(this.configuration).getIdentityAccessSummaries(requestParameters.id, requestParameters.type, requestParameters.limit, requestParameters.offset, requestParameters.count, requestParameters.filters, requestParameters.sorters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API returns a summary of the decisions made on an identity campaign certification. The decisions are summarized by type. A token with ORG_ADMIN or CERT_ADMIN authority is required to call this API. Reviewers for this certification can also call this API.
		     * @summary Summary of Certification Decisions
		     * @param {CertificationSummariesApiGetIdentityDecisionSummaryRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof CertificationSummariesApi
		     */
		    CertificationSummariesApi.prototype.getIdentityDecisionSummary = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.CertificationSummariesApiFp)(this.configuration).getIdentityDecisionSummary(requestParameters.id, requestParameters.filters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API returns a list of the identity summaries for a specific identity campaign certification. A token with ORG_ADMIN or CERT_ADMIN authority is required to call this API. Reviewers for this certification can also call this API.
		     * @summary Identity Summaries for Campaign Certification
		     * @param {CertificationSummariesApiGetIdentitySummariesRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof CertificationSummariesApi
		     */
		    CertificationSummariesApi.prototype.getIdentitySummaries = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.CertificationSummariesApiFp)(this.configuration).getIdentitySummaries(requestParameters.id, requestParameters.limit, requestParameters.offset, requestParameters.count, requestParameters.filters, requestParameters.sorters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API returns the summary for an identity on a specified identity campaign certification. A token with ORG_ADMIN or CERT_ADMIN authority is required to call this API. Reviewers for this certification can also call this API.
		     * @summary Summary for Identity
		     * @param {CertificationSummariesApiGetIdentitySummaryRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof CertificationSummariesApi
		     */
		    CertificationSummariesApi.prototype.getIdentitySummary = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.CertificationSummariesApiFp)(this.configuration).getIdentitySummary(requestParameters.id, requestParameters.identitySummaryId, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return CertificationSummariesApi;
		}(base_1.BaseAPI));
		exports.CertificationSummariesApi = CertificationSummariesApi;
		/**
		 * CertificationsApi - axios parameter creator
		 * @export
		 */
		var CertificationsApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * This API returns the certification task for the specified ID. A token with ORG_ADMIN or CERT_ADMIN authority is required to call this API. Reviewers for the specified certification can also call this API.
		         * @summary Certification Task by ID
		         * @param {string} id The task ID
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getCertificationTask: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getCertificationTask', 'id', id);
		                            localVarPath = "/certification-tasks/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns a single identity campaign certification by its ID. A token with ORG_ADMIN or CERT_ADMIN authority is required to call this API. Reviewers for this certification can also call this API. This API does not support requests for certifications assigned to Governance Groups.
		         * @summary Identity Certification by ID
		         * @param {string} id The certification id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getIdentityCertification: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getIdentityCertification', 'id', id);
		                            localVarPath = "/certifications/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns the permissions associated with an entitlement certification item based on the certification item\'s ID. A token with ORG_ADMIN or CERT_ADMIN authority is required to call this API. Reviewers for this certification can also call this API.
		         * @summary Permissions for Entitlement Certification Item
		         * @param {string} certificationId The certification ID
		         * @param {string} itemId The certification item ID
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **target**: *eq, sw*  **rights**: *ca*  Supported composite operators: *and, or*  All field values (second filter operands) are case-insensitive for this API.  Only a single *and* or *or* composite filter operator may be used. It must also be used between a target filter and a rights filter, not between 2 filters for the same field.  For example, the following is valid: &#x60;?filters&#x3D;rights+ca+(%22CREATE%22)+and+target+eq+%22SYS.OBJAUTH2%22&#x60;  The following is invalid: 1?filters&#x3D;rights+ca+(%22CREATE%22)+and+rights+ca+(%SELECT%22)1
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getIdentityCertificationItemPermissions: function (certificationId, itemId, filters, limit, offset, count, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'certificationId' is not null or undefined
		                            (0, common_1.assertParamExists)('getIdentityCertificationItemPermissions', 'certificationId', certificationId);
		                            // verify required parameter 'itemId' is not null or undefined
		                            (0, common_1.assertParamExists)('getIdentityCertificationItemPermissions', 'itemId', itemId);
		                            localVarPath = "/certifications/{certificationId}/access-review-items/{itemId}/permissions"
		                                .replace("{".concat("certificationId", "}"), encodeURIComponent(String(certificationId)))
		                                .replace("{".concat("itemId", "}"), encodeURIComponent(String(itemId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns a list of pending (`QUEUED` or `IN_PROGRESS`) certification tasks. Any authenticated token can call this API, but only certification tasks you are authorized to review will be returned.
		         * @summary List of Pending Certification Tasks
		         * @param {string} [reviewerIdentity] The ID of reviewer identity. *me* indicates the current user.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **targetId**: *eq, in*  **type**: *eq, in*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getPendingCertificationTasks: function (reviewerIdentity, limit, offset, count, filters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/certification-tasks";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (reviewerIdentity !== undefined) {
		                                localVarQueryParameter['reviewer-identity'] = reviewerIdentity;
		                            }
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns a list of reviewers for the certification. A token with ORG_ADMIN or CERT_ADMIN authority is required to call this API. Reviewers for this certification can also call this API.
		         * @summary List of Reviewers for certification
		         * @param {string} id The certification ID
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **name**: *eq, sw*  **email**: *eq, sw*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name, email**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listCertificationReviewers: function (id, limit, offset, count, filters, sorters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('listCertificationReviewers', 'id', id);
		                            localVarPath = "/certifications/{id}/reviewers"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns a list of access review items for an identity campaign certification. A token with ORG_ADMIN or CERT_ADMIN authority is required to call this API. Reviewers for this certification can also call this API. This API does not support requests for certifications assigned to Governance Groups.
		         * @summary List of Access Review Items
		         * @param {string} id The identity campaign certification ID
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **type**: *eq*  **access.type**: *eq*  **completed**: *eq, ne*  **identitySummary.id**: *eq, in*  **identitySummary.name**: *eq, sw*  **access.id**: *eq, in*  **access.name**: *eq, sw*  **entitlement.sourceName**: *eq, sw*  **accessProfile.sourceName**: *eq, sw*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **identitySummary.name, access.name, access.type, entitlement.sourceName, accessProfile.sourceName**
		         * @param {string} [entitlements] Filter results to view access review items that pertain to any of the specified comma-separated entitlement IDs.  An error will occur if this param is used with **access-profiles** or **roles** as only one of these query params can be used at a time.
		         * @param {string} [accessProfiles] Filter results to view access review items that pertain to any of the specified comma-separated access-profle IDs.  An error will occur if this param is used with **entitlements** or **roles** as only one of these query params can be used at a time.
		         * @param {string} [roles] Filter results to view access review items that pertain to any of the specified comma-separated role IDs.  An error will occur if this param is used with **entitlements** or **access-profiles** as only one of these query params can be used at a time.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listIdentityAccessReviewItems: function (id, limit, offset, count, filters, sorters, entitlements, accessProfiles, roles, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('listIdentityAccessReviewItems', 'id', id);
		                            localVarPath = "/certifications/{id}/access-review-items"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            if (entitlements !== undefined) {
		                                localVarQueryParameter['entitlements'] = entitlements;
		                            }
		                            if (accessProfiles !== undefined) {
		                                localVarQueryParameter['access-profiles'] = accessProfiles;
		                            }
		                            if (roles !== undefined) {
		                                localVarQueryParameter['roles'] = roles;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns a list of identity campaign certifications that satisfy the given query parameters. Any authenticated token can call this API, but only certifications you are authorized to review will be returned. This API does not support requests for certifications assigned to Governance Groups.
		         * @summary Identity Campaign Certifications by IDs
		         * @param {string} [reviewerIdentity] The ID of reviewer identity. *me* indicates the current user.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **campaign.id**: *eq, in*  **phase**: *eq*  **completed**: *eq, ne*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name, due, signed**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listIdentityCertifications: function (reviewerIdentity, limit, offset, count, filters, sorters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/certifications";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (reviewerIdentity !== undefined) {
		                                localVarQueryParameter['reviewer-identity'] = reviewerIdentity;
		                            }
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * The API makes a decision to approve or revoke one or more identity campaign certification items. A token with ORG_ADMIN or CERT_ADMIN authority is required to call this API. Reviewers for this certification can also call this API. This API does not support requests for certifications assigned to Governance Groups.
		         * @summary Decide on a Certification Item
		         * @param {string} id The ID of the identity campaign certification on which to make decisions
		         * @param {Array<ReviewDecision>} reviewDecision A non-empty array of decisions to be made.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        makeIdentityDecision: function (id, reviewDecision, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('makeIdentityDecision', 'id', id);
		                            // verify required parameter 'reviewDecision' is not null or undefined
		                            (0, common_1.assertParamExists)('makeIdentityDecision', 'reviewDecision', reviewDecision);
		                            localVarPath = "/certifications/{id}/decide"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(reviewDecision, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API reassigns up to 50 identities or items in an identity campaign certification to another reviewer. A token with ORG_ADMIN or CERT_ADMIN authority is required to call this API. Reviewers for this certification can also call this API. This API does not support requests for certifications assigned to Governance Groups.
		         * @summary Reassign Identities or Items
		         * @param {string} id The identity campaign certification ID
		         * @param {ReviewReassign} reviewReassign
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        reassignIdentityCertifications: function (id, reviewReassign, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('reassignIdentityCertifications', 'id', id);
		                            // verify required parameter 'reviewReassign' is not null or undefined
		                            (0, common_1.assertParamExists)('reassignIdentityCertifications', 'reviewReassign', reviewReassign);
		                            localVarPath = "/certifications/{id}/reassign"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(reviewReassign, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API finalizes all decisions made on an identity campaign certification and initiates any remediations required. A token with ORG_ADMIN or CERT_ADMIN authority is required to call this API. Reviewers for this certification can also call this API. This API does not support requests for certifications assigned to Governance Groups.
		         * @summary Finalize Identity Certification Decisions
		         * @param {string} id The identity campaign certification ID
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        signOffIdentityCertification: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('signOffIdentityCertification', 'id', id);
		                            localVarPath = "/certifications/{id}/sign-off"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API initiates a task to reassign up to 500 identities or items in an identity campaign certification to another reviewer. The `certification-tasks` API can be used to get an updated status on the task and determine when the reassignment is complete. A token with ORG_ADMIN or CERT_ADMIN authority is required to call this API. Reviewers for this certification can also call this API.
		         * @summary Reassign Certifications Asynchronously
		         * @param {string} id The identity campaign certification ID
		         * @param {ReviewReassign} reviewReassign
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        submitReassignCertsAsync: function (id, reviewReassign, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('submitReassignCertsAsync', 'id', id);
		                            // verify required parameter 'reviewReassign' is not null or undefined
		                            (0, common_1.assertParamExists)('submitReassignCertsAsync', 'reviewReassign', reviewReassign);
		                            localVarPath = "/certifications/{id}/reassign-async"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(reviewReassign, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.CertificationsApiAxiosParamCreator = CertificationsApiAxiosParamCreator;
		/**
		 * CertificationsApi - functional programming interface
		 * @export
		 */
		var CertificationsApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.CertificationsApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * This API returns the certification task for the specified ID. A token with ORG_ADMIN or CERT_ADMIN authority is required to call this API. Reviewers for the specified certification can also call this API.
		         * @summary Certification Task by ID
		         * @param {string} id The task ID
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getCertificationTask: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getCertificationTask(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns a single identity campaign certification by its ID. A token with ORG_ADMIN or CERT_ADMIN authority is required to call this API. Reviewers for this certification can also call this API. This API does not support requests for certifications assigned to Governance Groups.
		         * @summary Identity Certification by ID
		         * @param {string} id The certification id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getIdentityCertification: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getIdentityCertification(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns the permissions associated with an entitlement certification item based on the certification item\'s ID. A token with ORG_ADMIN or CERT_ADMIN authority is required to call this API. Reviewers for this certification can also call this API.
		         * @summary Permissions for Entitlement Certification Item
		         * @param {string} certificationId The certification ID
		         * @param {string} itemId The certification item ID
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **target**: *eq, sw*  **rights**: *ca*  Supported composite operators: *and, or*  All field values (second filter operands) are case-insensitive for this API.  Only a single *and* or *or* composite filter operator may be used. It must also be used between a target filter and a rights filter, not between 2 filters for the same field.  For example, the following is valid: &#x60;?filters&#x3D;rights+ca+(%22CREATE%22)+and+target+eq+%22SYS.OBJAUTH2%22&#x60;  The following is invalid: 1?filters&#x3D;rights+ca+(%22CREATE%22)+and+rights+ca+(%SELECT%22)1
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getIdentityCertificationItemPermissions: function (certificationId, itemId, filters, limit, offset, count, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getIdentityCertificationItemPermissions(certificationId, itemId, filters, limit, offset, count, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns a list of pending (`QUEUED` or `IN_PROGRESS`) certification tasks. Any authenticated token can call this API, but only certification tasks you are authorized to review will be returned.
		         * @summary List of Pending Certification Tasks
		         * @param {string} [reviewerIdentity] The ID of reviewer identity. *me* indicates the current user.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **targetId**: *eq, in*  **type**: *eq, in*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getPendingCertificationTasks: function (reviewerIdentity, limit, offset, count, filters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getPendingCertificationTasks(reviewerIdentity, limit, offset, count, filters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns a list of reviewers for the certification. A token with ORG_ADMIN or CERT_ADMIN authority is required to call this API. Reviewers for this certification can also call this API.
		         * @summary List of Reviewers for certification
		         * @param {string} id The certification ID
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **name**: *eq, sw*  **email**: *eq, sw*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name, email**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listCertificationReviewers: function (id, limit, offset, count, filters, sorters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listCertificationReviewers(id, limit, offset, count, filters, sorters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns a list of access review items for an identity campaign certification. A token with ORG_ADMIN or CERT_ADMIN authority is required to call this API. Reviewers for this certification can also call this API. This API does not support requests for certifications assigned to Governance Groups.
		         * @summary List of Access Review Items
		         * @param {string} id The identity campaign certification ID
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **type**: *eq*  **access.type**: *eq*  **completed**: *eq, ne*  **identitySummary.id**: *eq, in*  **identitySummary.name**: *eq, sw*  **access.id**: *eq, in*  **access.name**: *eq, sw*  **entitlement.sourceName**: *eq, sw*  **accessProfile.sourceName**: *eq, sw*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **identitySummary.name, access.name, access.type, entitlement.sourceName, accessProfile.sourceName**
		         * @param {string} [entitlements] Filter results to view access review items that pertain to any of the specified comma-separated entitlement IDs.  An error will occur if this param is used with **access-profiles** or **roles** as only one of these query params can be used at a time.
		         * @param {string} [accessProfiles] Filter results to view access review items that pertain to any of the specified comma-separated access-profle IDs.  An error will occur if this param is used with **entitlements** or **roles** as only one of these query params can be used at a time.
		         * @param {string} [roles] Filter results to view access review items that pertain to any of the specified comma-separated role IDs.  An error will occur if this param is used with **entitlements** or **access-profiles** as only one of these query params can be used at a time.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listIdentityAccessReviewItems: function (id, limit, offset, count, filters, sorters, entitlements, accessProfiles, roles, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listIdentityAccessReviewItems(id, limit, offset, count, filters, sorters, entitlements, accessProfiles, roles, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns a list of identity campaign certifications that satisfy the given query parameters. Any authenticated token can call this API, but only certifications you are authorized to review will be returned. This API does not support requests for certifications assigned to Governance Groups.
		         * @summary Identity Campaign Certifications by IDs
		         * @param {string} [reviewerIdentity] The ID of reviewer identity. *me* indicates the current user.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **campaign.id**: *eq, in*  **phase**: *eq*  **completed**: *eq, ne*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name, due, signed**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listIdentityCertifications: function (reviewerIdentity, limit, offset, count, filters, sorters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listIdentityCertifications(reviewerIdentity, limit, offset, count, filters, sorters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * The API makes a decision to approve or revoke one or more identity campaign certification items. A token with ORG_ADMIN or CERT_ADMIN authority is required to call this API. Reviewers for this certification can also call this API. This API does not support requests for certifications assigned to Governance Groups.
		         * @summary Decide on a Certification Item
		         * @param {string} id The ID of the identity campaign certification on which to make decisions
		         * @param {Array<ReviewDecision>} reviewDecision A non-empty array of decisions to be made.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        makeIdentityDecision: function (id, reviewDecision, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.makeIdentityDecision(id, reviewDecision, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API reassigns up to 50 identities or items in an identity campaign certification to another reviewer. A token with ORG_ADMIN or CERT_ADMIN authority is required to call this API. Reviewers for this certification can also call this API. This API does not support requests for certifications assigned to Governance Groups.
		         * @summary Reassign Identities or Items
		         * @param {string} id The identity campaign certification ID
		         * @param {ReviewReassign} reviewReassign
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        reassignIdentityCertifications: function (id, reviewReassign, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.reassignIdentityCertifications(id, reviewReassign, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API finalizes all decisions made on an identity campaign certification and initiates any remediations required. A token with ORG_ADMIN or CERT_ADMIN authority is required to call this API. Reviewers for this certification can also call this API. This API does not support requests for certifications assigned to Governance Groups.
		         * @summary Finalize Identity Certification Decisions
		         * @param {string} id The identity campaign certification ID
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        signOffIdentityCertification: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.signOffIdentityCertification(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API initiates a task to reassign up to 500 identities or items in an identity campaign certification to another reviewer. The `certification-tasks` API can be used to get an updated status on the task and determine when the reassignment is complete. A token with ORG_ADMIN or CERT_ADMIN authority is required to call this API. Reviewers for this certification can also call this API.
		         * @summary Reassign Certifications Asynchronously
		         * @param {string} id The identity campaign certification ID
		         * @param {ReviewReassign} reviewReassign
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        submitReassignCertsAsync: function (id, reviewReassign, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.submitReassignCertsAsync(id, reviewReassign, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.CertificationsApiFp = CertificationsApiFp;
		/**
		 * CertificationsApi - factory interface
		 * @export
		 */
		var CertificationsApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.CertificationsApiFp)(configuration);
		    return {
		        /**
		         * This API returns the certification task for the specified ID. A token with ORG_ADMIN or CERT_ADMIN authority is required to call this API. Reviewers for the specified certification can also call this API.
		         * @summary Certification Task by ID
		         * @param {string} id The task ID
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getCertificationTask: function (id, axiosOptions) {
		            return localVarFp.getCertificationTask(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API returns a single identity campaign certification by its ID. A token with ORG_ADMIN or CERT_ADMIN authority is required to call this API. Reviewers for this certification can also call this API. This API does not support requests for certifications assigned to Governance Groups.
		         * @summary Identity Certification by ID
		         * @param {string} id The certification id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getIdentityCertification: function (id, axiosOptions) {
		            return localVarFp.getIdentityCertification(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API returns the permissions associated with an entitlement certification item based on the certification item\'s ID. A token with ORG_ADMIN or CERT_ADMIN authority is required to call this API. Reviewers for this certification can also call this API.
		         * @summary Permissions for Entitlement Certification Item
		         * @param {string} certificationId The certification ID
		         * @param {string} itemId The certification item ID
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **target**: *eq, sw*  **rights**: *ca*  Supported composite operators: *and, or*  All field values (second filter operands) are case-insensitive for this API.  Only a single *and* or *or* composite filter operator may be used. It must also be used between a target filter and a rights filter, not between 2 filters for the same field.  For example, the following is valid: &#x60;?filters&#x3D;rights+ca+(%22CREATE%22)+and+target+eq+%22SYS.OBJAUTH2%22&#x60;  The following is invalid: 1?filters&#x3D;rights+ca+(%22CREATE%22)+and+rights+ca+(%SELECT%22)1
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getIdentityCertificationItemPermissions: function (certificationId, itemId, filters, limit, offset, count, axiosOptions) {
		            return localVarFp.getIdentityCertificationItemPermissions(certificationId, itemId, filters, limit, offset, count, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API returns a list of pending (`QUEUED` or `IN_PROGRESS`) certification tasks. Any authenticated token can call this API, but only certification tasks you are authorized to review will be returned.
		         * @summary List of Pending Certification Tasks
		         * @param {string} [reviewerIdentity] The ID of reviewer identity. *me* indicates the current user.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **targetId**: *eq, in*  **type**: *eq, in*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getPendingCertificationTasks: function (reviewerIdentity, limit, offset, count, filters, axiosOptions) {
		            return localVarFp.getPendingCertificationTasks(reviewerIdentity, limit, offset, count, filters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API returns a list of reviewers for the certification. A token with ORG_ADMIN or CERT_ADMIN authority is required to call this API. Reviewers for this certification can also call this API.
		         * @summary List of Reviewers for certification
		         * @param {string} id The certification ID
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **name**: *eq, sw*  **email**: *eq, sw*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name, email**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listCertificationReviewers: function (id, limit, offset, count, filters, sorters, axiosOptions) {
		            return localVarFp.listCertificationReviewers(id, limit, offset, count, filters, sorters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API returns a list of access review items for an identity campaign certification. A token with ORG_ADMIN or CERT_ADMIN authority is required to call this API. Reviewers for this certification can also call this API. This API does not support requests for certifications assigned to Governance Groups.
		         * @summary List of Access Review Items
		         * @param {string} id The identity campaign certification ID
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **type**: *eq*  **access.type**: *eq*  **completed**: *eq, ne*  **identitySummary.id**: *eq, in*  **identitySummary.name**: *eq, sw*  **access.id**: *eq, in*  **access.name**: *eq, sw*  **entitlement.sourceName**: *eq, sw*  **accessProfile.sourceName**: *eq, sw*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **identitySummary.name, access.name, access.type, entitlement.sourceName, accessProfile.sourceName**
		         * @param {string} [entitlements] Filter results to view access review items that pertain to any of the specified comma-separated entitlement IDs.  An error will occur if this param is used with **access-profiles** or **roles** as only one of these query params can be used at a time.
		         * @param {string} [accessProfiles] Filter results to view access review items that pertain to any of the specified comma-separated access-profle IDs.  An error will occur if this param is used with **entitlements** or **roles** as only one of these query params can be used at a time.
		         * @param {string} [roles] Filter results to view access review items that pertain to any of the specified comma-separated role IDs.  An error will occur if this param is used with **entitlements** or **access-profiles** as only one of these query params can be used at a time.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listIdentityAccessReviewItems: function (id, limit, offset, count, filters, sorters, entitlements, accessProfiles, roles, axiosOptions) {
		            return localVarFp.listIdentityAccessReviewItems(id, limit, offset, count, filters, sorters, entitlements, accessProfiles, roles, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API returns a list of identity campaign certifications that satisfy the given query parameters. Any authenticated token can call this API, but only certifications you are authorized to review will be returned. This API does not support requests for certifications assigned to Governance Groups.
		         * @summary Identity Campaign Certifications by IDs
		         * @param {string} [reviewerIdentity] The ID of reviewer identity. *me* indicates the current user.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **campaign.id**: *eq, in*  **phase**: *eq*  **completed**: *eq, ne*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name, due, signed**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listIdentityCertifications: function (reviewerIdentity, limit, offset, count, filters, sorters, axiosOptions) {
		            return localVarFp.listIdentityCertifications(reviewerIdentity, limit, offset, count, filters, sorters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * The API makes a decision to approve or revoke one or more identity campaign certification items. A token with ORG_ADMIN or CERT_ADMIN authority is required to call this API. Reviewers for this certification can also call this API. This API does not support requests for certifications assigned to Governance Groups.
		         * @summary Decide on a Certification Item
		         * @param {string} id The ID of the identity campaign certification on which to make decisions
		         * @param {Array<ReviewDecision>} reviewDecision A non-empty array of decisions to be made.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        makeIdentityDecision: function (id, reviewDecision, axiosOptions) {
		            return localVarFp.makeIdentityDecision(id, reviewDecision, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API reassigns up to 50 identities or items in an identity campaign certification to another reviewer. A token with ORG_ADMIN or CERT_ADMIN authority is required to call this API. Reviewers for this certification can also call this API. This API does not support requests for certifications assigned to Governance Groups.
		         * @summary Reassign Identities or Items
		         * @param {string} id The identity campaign certification ID
		         * @param {ReviewReassign} reviewReassign
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        reassignIdentityCertifications: function (id, reviewReassign, axiosOptions) {
		            return localVarFp.reassignIdentityCertifications(id, reviewReassign, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API finalizes all decisions made on an identity campaign certification and initiates any remediations required. A token with ORG_ADMIN or CERT_ADMIN authority is required to call this API. Reviewers for this certification can also call this API. This API does not support requests for certifications assigned to Governance Groups.
		         * @summary Finalize Identity Certification Decisions
		         * @param {string} id The identity campaign certification ID
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        signOffIdentityCertification: function (id, axiosOptions) {
		            return localVarFp.signOffIdentityCertification(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API initiates a task to reassign up to 500 identities or items in an identity campaign certification to another reviewer. The `certification-tasks` API can be used to get an updated status on the task and determine when the reassignment is complete. A token with ORG_ADMIN or CERT_ADMIN authority is required to call this API. Reviewers for this certification can also call this API.
		         * @summary Reassign Certifications Asynchronously
		         * @param {string} id The identity campaign certification ID
		         * @param {ReviewReassign} reviewReassign
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        submitReassignCertsAsync: function (id, reviewReassign, axiosOptions) {
		            return localVarFp.submitReassignCertsAsync(id, reviewReassign, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.CertificationsApiFactory = CertificationsApiFactory;
		/**
		 * CertificationsApi - object-oriented interface
		 * @export
		 * @class CertificationsApi
		 * @extends {BaseAPI}
		 */
		var CertificationsApi = /** @class */ (function (_super) {
		    __extends(CertificationsApi, _super);
		    function CertificationsApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * This API returns the certification task for the specified ID. A token with ORG_ADMIN or CERT_ADMIN authority is required to call this API. Reviewers for the specified certification can also call this API.
		     * @summary Certification Task by ID
		     * @param {CertificationsApiGetCertificationTaskRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof CertificationsApi
		     */
		    CertificationsApi.prototype.getCertificationTask = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.CertificationsApiFp)(this.configuration).getCertificationTask(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API returns a single identity campaign certification by its ID. A token with ORG_ADMIN or CERT_ADMIN authority is required to call this API. Reviewers for this certification can also call this API. This API does not support requests for certifications assigned to Governance Groups.
		     * @summary Identity Certification by ID
		     * @param {CertificationsApiGetIdentityCertificationRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof CertificationsApi
		     */
		    CertificationsApi.prototype.getIdentityCertification = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.CertificationsApiFp)(this.configuration).getIdentityCertification(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API returns the permissions associated with an entitlement certification item based on the certification item\'s ID. A token with ORG_ADMIN or CERT_ADMIN authority is required to call this API. Reviewers for this certification can also call this API.
		     * @summary Permissions for Entitlement Certification Item
		     * @param {CertificationsApiGetIdentityCertificationItemPermissionsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof CertificationsApi
		     */
		    CertificationsApi.prototype.getIdentityCertificationItemPermissions = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.CertificationsApiFp)(this.configuration).getIdentityCertificationItemPermissions(requestParameters.certificationId, requestParameters.itemId, requestParameters.filters, requestParameters.limit, requestParameters.offset, requestParameters.count, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API returns a list of pending (`QUEUED` or `IN_PROGRESS`) certification tasks. Any authenticated token can call this API, but only certification tasks you are authorized to review will be returned.
		     * @summary List of Pending Certification Tasks
		     * @param {CertificationsApiGetPendingCertificationTasksRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof CertificationsApi
		     */
		    CertificationsApi.prototype.getPendingCertificationTasks = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.CertificationsApiFp)(this.configuration).getPendingCertificationTasks(requestParameters.reviewerIdentity, requestParameters.limit, requestParameters.offset, requestParameters.count, requestParameters.filters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API returns a list of reviewers for the certification. A token with ORG_ADMIN or CERT_ADMIN authority is required to call this API. Reviewers for this certification can also call this API.
		     * @summary List of Reviewers for certification
		     * @param {CertificationsApiListCertificationReviewersRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof CertificationsApi
		     */
		    CertificationsApi.prototype.listCertificationReviewers = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.CertificationsApiFp)(this.configuration).listCertificationReviewers(requestParameters.id, requestParameters.limit, requestParameters.offset, requestParameters.count, requestParameters.filters, requestParameters.sorters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API returns a list of access review items for an identity campaign certification. A token with ORG_ADMIN or CERT_ADMIN authority is required to call this API. Reviewers for this certification can also call this API. This API does not support requests for certifications assigned to Governance Groups.
		     * @summary List of Access Review Items
		     * @param {CertificationsApiListIdentityAccessReviewItemsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof CertificationsApi
		     */
		    CertificationsApi.prototype.listIdentityAccessReviewItems = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.CertificationsApiFp)(this.configuration).listIdentityAccessReviewItems(requestParameters.id, requestParameters.limit, requestParameters.offset, requestParameters.count, requestParameters.filters, requestParameters.sorters, requestParameters.entitlements, requestParameters.accessProfiles, requestParameters.roles, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API returns a list of identity campaign certifications that satisfy the given query parameters. Any authenticated token can call this API, but only certifications you are authorized to review will be returned. This API does not support requests for certifications assigned to Governance Groups.
		     * @summary Identity Campaign Certifications by IDs
		     * @param {CertificationsApiListIdentityCertificationsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof CertificationsApi
		     */
		    CertificationsApi.prototype.listIdentityCertifications = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.CertificationsApiFp)(this.configuration).listIdentityCertifications(requestParameters.reviewerIdentity, requestParameters.limit, requestParameters.offset, requestParameters.count, requestParameters.filters, requestParameters.sorters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * The API makes a decision to approve or revoke one or more identity campaign certification items. A token with ORG_ADMIN or CERT_ADMIN authority is required to call this API. Reviewers for this certification can also call this API. This API does not support requests for certifications assigned to Governance Groups.
		     * @summary Decide on a Certification Item
		     * @param {CertificationsApiMakeIdentityDecisionRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof CertificationsApi
		     */
		    CertificationsApi.prototype.makeIdentityDecision = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.CertificationsApiFp)(this.configuration).makeIdentityDecision(requestParameters.id, requestParameters.reviewDecision, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API reassigns up to 50 identities or items in an identity campaign certification to another reviewer. A token with ORG_ADMIN or CERT_ADMIN authority is required to call this API. Reviewers for this certification can also call this API. This API does not support requests for certifications assigned to Governance Groups.
		     * @summary Reassign Identities or Items
		     * @param {CertificationsApiReassignIdentityCertificationsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof CertificationsApi
		     */
		    CertificationsApi.prototype.reassignIdentityCertifications = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.CertificationsApiFp)(this.configuration).reassignIdentityCertifications(requestParameters.id, requestParameters.reviewReassign, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API finalizes all decisions made on an identity campaign certification and initiates any remediations required. A token with ORG_ADMIN or CERT_ADMIN authority is required to call this API. Reviewers for this certification can also call this API. This API does not support requests for certifications assigned to Governance Groups.
		     * @summary Finalize Identity Certification Decisions
		     * @param {CertificationsApiSignOffIdentityCertificationRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof CertificationsApi
		     */
		    CertificationsApi.prototype.signOffIdentityCertification = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.CertificationsApiFp)(this.configuration).signOffIdentityCertification(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API initiates a task to reassign up to 500 identities or items in an identity campaign certification to another reviewer. The `certification-tasks` API can be used to get an updated status on the task and determine when the reassignment is complete. A token with ORG_ADMIN or CERT_ADMIN authority is required to call this API. Reviewers for this certification can also call this API.
		     * @summary Reassign Certifications Asynchronously
		     * @param {CertificationsApiSubmitReassignCertsAsyncRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof CertificationsApi
		     */
		    CertificationsApi.prototype.submitReassignCertsAsync = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.CertificationsApiFp)(this.configuration).submitReassignCertsAsync(requestParameters.id, requestParameters.reviewReassign, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return CertificationsApi;
		}(base_1.BaseAPI));
		exports.CertificationsApi = CertificationsApi;
		/**
		 * ConnectorsApi - axios parameter creator
		 * @export
		 */
		var ConnectorsApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * Create custom connector. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Create custom connector
		         * @param {V3CreateConnectorDto} v3CreateConnectorDto
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createCustomConnector: function (v3CreateConnectorDto, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'v3CreateConnectorDto' is not null or undefined
		                            (0, common_1.assertParamExists)('createCustomConnector', 'v3CreateConnectorDto', v3CreateConnectorDto);
		                            localVarPath = "/connectors";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(v3CreateConnectorDto, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Delete a custom connector that using its script name. A token with ORG_ADMIN authority is required to call this API.
		         * @param {string} scriptName The scriptName value of the connector. Scriptname is the unique id generated at connector creation.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteCustomConnector: function (scriptName, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'scriptName' is not null or undefined
		                            (0, common_1.assertParamExists)('deleteCustomConnector', 'scriptName', scriptName);
		                            localVarPath = "/connectors/{scriptName}"
		                                .replace("{".concat("scriptName", "}"), encodeURIComponent(String(scriptName)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'DELETE' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Fetches a connector that using its script name. A token with ORG_ADMIN authority is required to call this API.
		         * @param {string} scriptName The scriptName value of the connector. Scriptname is the unique id generated at connector creation.
		         * @param {'de' | 'false' | 'fi' | 'sv' | 'ru' | 'pt' | 'ko' | 'zh-TW' | 'en' | 'it' | 'fr' | 'zh-CN' | 'hu' | 'es' | 'cs' | 'ja' | 'pl' | 'da' | 'nl'} [locale] The locale to apply to the config. If no viable locale is given, it will default to \&quot;en\&quot;
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getConnector: function (scriptName, locale, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'scriptName' is not null or undefined
		                            (0, common_1.assertParamExists)('getConnector', 'scriptName', scriptName);
		                            localVarPath = "/connectors/{scriptName}"
		                                .replace("{".concat("scriptName", "}"), encodeURIComponent(String(scriptName)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (locale !== undefined) {
		                                localVarQueryParameter['locale'] = locale;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Fetches a connector\'s correlation config using its script name. A token with ORG_ADMIN authority is required to call this API.
		         * @param {string} scriptName The scriptName value of the connector. Scriptname is the unique id generated at connector creation.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getConnectorCorrelationConfig: function (scriptName, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'scriptName' is not null or undefined
		                            (0, common_1.assertParamExists)('getConnectorCorrelationConfig', 'scriptName', scriptName);
		                            localVarPath = "/connectors/{scriptName}/correlation-config"
		                                .replace("{".concat("scriptName", "}"), encodeURIComponent(String(scriptName)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Fetches a connector\'s source config using its script name. A token with ORG_ADMIN authority is required to call this API.
		         * @param {string} scriptName The scriptName value of the connector. Scriptname is the unique id generated at connector creation.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getConnectorSourceConfig: function (scriptName, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'scriptName' is not null or undefined
		                            (0, common_1.assertParamExists)('getConnectorSourceConfig', 'scriptName', scriptName);
		                            localVarPath = "/connectors/{scriptName}/source-config"
		                                .replace("{".concat("scriptName", "}"), encodeURIComponent(String(scriptName)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Fetches a connector\'s source template using its script name. A token with ORG_ADMIN authority is required to call this API.
		         * @param {string} scriptName The scriptName value of the connector. Scriptname is the unique id generated at connector creation.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getConnectorSourceTemplate: function (scriptName, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'scriptName' is not null or undefined
		                            (0, common_1.assertParamExists)('getConnectorSourceTemplate', 'scriptName', scriptName);
		                            localVarPath = "/connectors/{scriptName}/source-template"
		                                .replace("{".concat("scriptName", "}"), encodeURIComponent(String(scriptName)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Fetches a connector\'s translations using its script name. A token with ORG_ADMIN authority is required to call this API.
		         * @param {string} scriptName The scriptName value of the connector. Scriptname is the unique id generated at connector creation.
		         * @param {'de' | 'false' | 'fi' | 'sv' | 'ru' | 'pt' | 'ko' | 'zh-TW' | 'en' | 'it' | 'fr' | 'zh-CN' | 'hu' | 'es' | 'cs' | 'ja' | 'pl' | 'da' | 'nl'} locale The locale to apply to the config. If no viable locale is given, it will default to \&quot;en\&quot;
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getConnectorTranslations: function (scriptName, locale, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'scriptName' is not null or undefined
		                            (0, common_1.assertParamExists)('getConnectorTranslations', 'scriptName', scriptName);
		                            // verify required parameter 'locale' is not null or undefined
		                            (0, common_1.assertParamExists)('getConnectorTranslations', 'locale', locale);
		                            localVarPath = "/connectors/{scriptName}/translations/{locale}"
		                                .replace("{".concat("scriptName", "}"), encodeURIComponent(String(scriptName)))
		                                .replace("{".concat("locale", "}"), encodeURIComponent(String(locale)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Update a connector\'s correlation config using its script name. A token with ORG_ADMIN authority is required to call this API.
		         * @param {string} scriptName The scriptName value of the connector. Scriptname is the unique id generated at connector creation.
		         * @param {any} file connector correlation config xml file
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putCorrelationConfig: function (scriptName, file, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, localVarFormParams, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'scriptName' is not null or undefined
		                            (0, common_1.assertParamExists)('putCorrelationConfig', 'scriptName', scriptName);
		                            // verify required parameter 'file' is not null or undefined
		                            (0, common_1.assertParamExists)('putCorrelationConfig', 'file', file);
		                            localVarPath = "/connectors/{scriptName}/correlation-config"
		                                .replace("{".concat("scriptName", "}"), encodeURIComponent(String(scriptName)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PUT' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            localVarFormParams = new ((configuration && configuration.formDataCtor) || FormData)();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (file !== undefined) {
		                                localVarFormParams.append('file', file);
		                            }
		                            localVarHeaderParameter['Content-Type'] = 'multipart/form-data';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = localVarFormParams;
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Update a connector\'s source config using its script name. A token with ORG_ADMIN authority is required to call this API.
		         * @param {string} scriptName The scriptName value of the connector. Scriptname is the unique id generated at connector creation.
		         * @param {any} file connector source config xml file
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putSourceConfig: function (scriptName, file, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, localVarFormParams, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'scriptName' is not null or undefined
		                            (0, common_1.assertParamExists)('putSourceConfig', 'scriptName', scriptName);
		                            // verify required parameter 'file' is not null or undefined
		                            (0, common_1.assertParamExists)('putSourceConfig', 'file', file);
		                            localVarPath = "/connectors/{scriptName}/source-config"
		                                .replace("{".concat("scriptName", "}"), encodeURIComponent(String(scriptName)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PUT' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            localVarFormParams = new ((configuration && configuration.formDataCtor) || FormData)();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (file !== undefined) {
		                                localVarFormParams.append('file', file);
		                            }
		                            localVarHeaderParameter['Content-Type'] = 'multipart/form-data';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = localVarFormParams;
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Update a connector\'s source template using its script name. A token with ORG_ADMIN authority is required to call this API.
		         * @param {string} scriptName The scriptName value of the connector. Scriptname is the unique id generated at connector creation.
		         * @param {any} file connector source template xml file
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putSourceTemplate: function (scriptName, file, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, localVarFormParams, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'scriptName' is not null or undefined
		                            (0, common_1.assertParamExists)('putSourceTemplate', 'scriptName', scriptName);
		                            // verify required parameter 'file' is not null or undefined
		                            (0, common_1.assertParamExists)('putSourceTemplate', 'file', file);
		                            localVarPath = "/connectors/{scriptName}/source-template"
		                                .replace("{".concat("scriptName", "}"), encodeURIComponent(String(scriptName)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PUT' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            localVarFormParams = new ((configuration && configuration.formDataCtor) || FormData)();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (file !== undefined) {
		                                localVarFormParams.append('file', file);
		                            }
		                            localVarHeaderParameter['Content-Type'] = 'multipart/form-data';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = localVarFormParams;
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Update a connector\'s translations using its script name. A token with ORG_ADMIN authority is required to call this API.
		         * @param {string} scriptName The scriptName value of the connector. Scriptname is the unique id generated at connector creation.
		         * @param {'de' | 'false' | 'fi' | 'sv' | 'ru' | 'pt' | 'ko' | 'zh-TW' | 'en' | 'it' | 'fr' | 'zh-CN' | 'hu' | 'es' | 'cs' | 'ja' | 'pl' | 'da' | 'nl'} locale The locale to apply to the config. If no viable locale is given, it will default to \&quot;en\&quot;
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putTranslations: function (scriptName, locale, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'scriptName' is not null or undefined
		                            (0, common_1.assertParamExists)('putTranslations', 'scriptName', scriptName);
		                            // verify required parameter 'locale' is not null or undefined
		                            (0, common_1.assertParamExists)('putTranslations', 'locale', locale);
		                            localVarPath = "/connectors/{scriptName}/translations/{locale}"
		                                .replace("{".concat("scriptName", "}"), encodeURIComponent(String(scriptName)))
		                                .replace("{".concat("locale", "}"), encodeURIComponent(String(locale)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PUT' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Patch a custom connector that using its script name. A token with ORG_ADMIN authority is required to call this API. The following fields are patchable: * connectorMetadata * applicationXml * correlationConfigXml * sourceConfigXml
		         * @param {string} scriptName The scriptName value of the connector. Scriptname is the unique id generated at connector creation.
		         * @param {Array<JsonPatchOperation>} jsonPatchOperation A list of connector detail update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateConnector: function (scriptName, jsonPatchOperation, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'scriptName' is not null or undefined
		                            (0, common_1.assertParamExists)('updateConnector', 'scriptName', scriptName);
		                            // verify required parameter 'jsonPatchOperation' is not null or undefined
		                            (0, common_1.assertParamExists)('updateConnector', 'jsonPatchOperation', jsonPatchOperation);
		                            localVarPath = "/connectors/{scriptName}"
		                                .replace("{".concat("scriptName", "}"), encodeURIComponent(String(scriptName)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PATCH' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json-patch+json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(jsonPatchOperation, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.ConnectorsApiAxiosParamCreator = ConnectorsApiAxiosParamCreator;
		/**
		 * ConnectorsApi - functional programming interface
		 * @export
		 */
		var ConnectorsApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.ConnectorsApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * Create custom connector. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Create custom connector
		         * @param {V3CreateConnectorDto} v3CreateConnectorDto
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createCustomConnector: function (v3CreateConnectorDto, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.createCustomConnector(v3CreateConnectorDto, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Delete a custom connector that using its script name. A token with ORG_ADMIN authority is required to call this API.
		         * @param {string} scriptName The scriptName value of the connector. Scriptname is the unique id generated at connector creation.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteCustomConnector: function (scriptName, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.deleteCustomConnector(scriptName, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Fetches a connector that using its script name. A token with ORG_ADMIN authority is required to call this API.
		         * @param {string} scriptName The scriptName value of the connector. Scriptname is the unique id generated at connector creation.
		         * @param {'de' | 'false' | 'fi' | 'sv' | 'ru' | 'pt' | 'ko' | 'zh-TW' | 'en' | 'it' | 'fr' | 'zh-CN' | 'hu' | 'es' | 'cs' | 'ja' | 'pl' | 'da' | 'nl'} [locale] The locale to apply to the config. If no viable locale is given, it will default to \&quot;en\&quot;
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getConnector: function (scriptName, locale, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getConnector(scriptName, locale, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Fetches a connector\'s correlation config using its script name. A token with ORG_ADMIN authority is required to call this API.
		         * @param {string} scriptName The scriptName value of the connector. Scriptname is the unique id generated at connector creation.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getConnectorCorrelationConfig: function (scriptName, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getConnectorCorrelationConfig(scriptName, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Fetches a connector\'s source config using its script name. A token with ORG_ADMIN authority is required to call this API.
		         * @param {string} scriptName The scriptName value of the connector. Scriptname is the unique id generated at connector creation.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getConnectorSourceConfig: function (scriptName, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getConnectorSourceConfig(scriptName, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Fetches a connector\'s source template using its script name. A token with ORG_ADMIN authority is required to call this API.
		         * @param {string} scriptName The scriptName value of the connector. Scriptname is the unique id generated at connector creation.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getConnectorSourceTemplate: function (scriptName, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getConnectorSourceTemplate(scriptName, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Fetches a connector\'s translations using its script name. A token with ORG_ADMIN authority is required to call this API.
		         * @param {string} scriptName The scriptName value of the connector. Scriptname is the unique id generated at connector creation.
		         * @param {'de' | 'false' | 'fi' | 'sv' | 'ru' | 'pt' | 'ko' | 'zh-TW' | 'en' | 'it' | 'fr' | 'zh-CN' | 'hu' | 'es' | 'cs' | 'ja' | 'pl' | 'da' | 'nl'} locale The locale to apply to the config. If no viable locale is given, it will default to \&quot;en\&quot;
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getConnectorTranslations: function (scriptName, locale, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getConnectorTranslations(scriptName, locale, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Update a connector\'s correlation config using its script name. A token with ORG_ADMIN authority is required to call this API.
		         * @param {string} scriptName The scriptName value of the connector. Scriptname is the unique id generated at connector creation.
		         * @param {any} file connector correlation config xml file
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putCorrelationConfig: function (scriptName, file, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.putCorrelationConfig(scriptName, file, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Update a connector\'s source config using its script name. A token with ORG_ADMIN authority is required to call this API.
		         * @param {string} scriptName The scriptName value of the connector. Scriptname is the unique id generated at connector creation.
		         * @param {any} file connector source config xml file
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putSourceConfig: function (scriptName, file, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.putSourceConfig(scriptName, file, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Update a connector\'s source template using its script name. A token with ORG_ADMIN authority is required to call this API.
		         * @param {string} scriptName The scriptName value of the connector. Scriptname is the unique id generated at connector creation.
		         * @param {any} file connector source template xml file
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putSourceTemplate: function (scriptName, file, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.putSourceTemplate(scriptName, file, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Update a connector\'s translations using its script name. A token with ORG_ADMIN authority is required to call this API.
		         * @param {string} scriptName The scriptName value of the connector. Scriptname is the unique id generated at connector creation.
		         * @param {'de' | 'false' | 'fi' | 'sv' | 'ru' | 'pt' | 'ko' | 'zh-TW' | 'en' | 'it' | 'fr' | 'zh-CN' | 'hu' | 'es' | 'cs' | 'ja' | 'pl' | 'da' | 'nl'} locale The locale to apply to the config. If no viable locale is given, it will default to \&quot;en\&quot;
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putTranslations: function (scriptName, locale, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.putTranslations(scriptName, locale, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Patch a custom connector that using its script name. A token with ORG_ADMIN authority is required to call this API. The following fields are patchable: * connectorMetadata * applicationXml * correlationConfigXml * sourceConfigXml
		         * @param {string} scriptName The scriptName value of the connector. Scriptname is the unique id generated at connector creation.
		         * @param {Array<JsonPatchOperation>} jsonPatchOperation A list of connector detail update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateConnector: function (scriptName, jsonPatchOperation, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.updateConnector(scriptName, jsonPatchOperation, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.ConnectorsApiFp = ConnectorsApiFp;
		/**
		 * ConnectorsApi - factory interface
		 * @export
		 */
		var ConnectorsApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.ConnectorsApiFp)(configuration);
		    return {
		        /**
		         * Create custom connector. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Create custom connector
		         * @param {V3CreateConnectorDto} v3CreateConnectorDto
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createCustomConnector: function (v3CreateConnectorDto, axiosOptions) {
		            return localVarFp.createCustomConnector(v3CreateConnectorDto, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Delete a custom connector that using its script name. A token with ORG_ADMIN authority is required to call this API.
		         * @param {string} scriptName The scriptName value of the connector. Scriptname is the unique id generated at connector creation.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteCustomConnector: function (scriptName, axiosOptions) {
		            return localVarFp.deleteCustomConnector(scriptName, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Fetches a connector that using its script name. A token with ORG_ADMIN authority is required to call this API.
		         * @param {string} scriptName The scriptName value of the connector. Scriptname is the unique id generated at connector creation.
		         * @param {'de' | 'false' | 'fi' | 'sv' | 'ru' | 'pt' | 'ko' | 'zh-TW' | 'en' | 'it' | 'fr' | 'zh-CN' | 'hu' | 'es' | 'cs' | 'ja' | 'pl' | 'da' | 'nl'} [locale] The locale to apply to the config. If no viable locale is given, it will default to \&quot;en\&quot;
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getConnector: function (scriptName, locale, axiosOptions) {
		            return localVarFp.getConnector(scriptName, locale, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Fetches a connector\'s correlation config using its script name. A token with ORG_ADMIN authority is required to call this API.
		         * @param {string} scriptName The scriptName value of the connector. Scriptname is the unique id generated at connector creation.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getConnectorCorrelationConfig: function (scriptName, axiosOptions) {
		            return localVarFp.getConnectorCorrelationConfig(scriptName, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Fetches a connector\'s source config using its script name. A token with ORG_ADMIN authority is required to call this API.
		         * @param {string} scriptName The scriptName value of the connector. Scriptname is the unique id generated at connector creation.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getConnectorSourceConfig: function (scriptName, axiosOptions) {
		            return localVarFp.getConnectorSourceConfig(scriptName, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Fetches a connector\'s source template using its script name. A token with ORG_ADMIN authority is required to call this API.
		         * @param {string} scriptName The scriptName value of the connector. Scriptname is the unique id generated at connector creation.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getConnectorSourceTemplate: function (scriptName, axiosOptions) {
		            return localVarFp.getConnectorSourceTemplate(scriptName, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Fetches a connector\'s translations using its script name. A token with ORG_ADMIN authority is required to call this API.
		         * @param {string} scriptName The scriptName value of the connector. Scriptname is the unique id generated at connector creation.
		         * @param {'de' | 'false' | 'fi' | 'sv' | 'ru' | 'pt' | 'ko' | 'zh-TW' | 'en' | 'it' | 'fr' | 'zh-CN' | 'hu' | 'es' | 'cs' | 'ja' | 'pl' | 'da' | 'nl'} locale The locale to apply to the config. If no viable locale is given, it will default to \&quot;en\&quot;
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getConnectorTranslations: function (scriptName, locale, axiosOptions) {
		            return localVarFp.getConnectorTranslations(scriptName, locale, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Update a connector\'s correlation config using its script name. A token with ORG_ADMIN authority is required to call this API.
		         * @param {string} scriptName The scriptName value of the connector. Scriptname is the unique id generated at connector creation.
		         * @param {any} file connector correlation config xml file
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putCorrelationConfig: function (scriptName, file, axiosOptions) {
		            return localVarFp.putCorrelationConfig(scriptName, file, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Update a connector\'s source config using its script name. A token with ORG_ADMIN authority is required to call this API.
		         * @param {string} scriptName The scriptName value of the connector. Scriptname is the unique id generated at connector creation.
		         * @param {any} file connector source config xml file
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putSourceConfig: function (scriptName, file, axiosOptions) {
		            return localVarFp.putSourceConfig(scriptName, file, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Update a connector\'s source template using its script name. A token with ORG_ADMIN authority is required to call this API.
		         * @param {string} scriptName The scriptName value of the connector. Scriptname is the unique id generated at connector creation.
		         * @param {any} file connector source template xml file
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putSourceTemplate: function (scriptName, file, axiosOptions) {
		            return localVarFp.putSourceTemplate(scriptName, file, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Update a connector\'s translations using its script name. A token with ORG_ADMIN authority is required to call this API.
		         * @param {string} scriptName The scriptName value of the connector. Scriptname is the unique id generated at connector creation.
		         * @param {'de' | 'false' | 'fi' | 'sv' | 'ru' | 'pt' | 'ko' | 'zh-TW' | 'en' | 'it' | 'fr' | 'zh-CN' | 'hu' | 'es' | 'cs' | 'ja' | 'pl' | 'da' | 'nl'} locale The locale to apply to the config. If no viable locale is given, it will default to \&quot;en\&quot;
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putTranslations: function (scriptName, locale, axiosOptions) {
		            return localVarFp.putTranslations(scriptName, locale, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Patch a custom connector that using its script name. A token with ORG_ADMIN authority is required to call this API. The following fields are patchable: * connectorMetadata * applicationXml * correlationConfigXml * sourceConfigXml
		         * @param {string} scriptName The scriptName value of the connector. Scriptname is the unique id generated at connector creation.
		         * @param {Array<JsonPatchOperation>} jsonPatchOperation A list of connector detail update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateConnector: function (scriptName, jsonPatchOperation, axiosOptions) {
		            return localVarFp.updateConnector(scriptName, jsonPatchOperation, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.ConnectorsApiFactory = ConnectorsApiFactory;
		/**
		 * ConnectorsApi - object-oriented interface
		 * @export
		 * @class ConnectorsApi
		 * @extends {BaseAPI}
		 */
		var ConnectorsApi = /** @class */ (function (_super) {
		    __extends(ConnectorsApi, _super);
		    function ConnectorsApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * Create custom connector. A token with ORG_ADMIN authority is required to call this API.
		     * @summary Create custom connector
		     * @param {ConnectorsApiCreateCustomConnectorRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof ConnectorsApi
		     */
		    ConnectorsApi.prototype.createCustomConnector = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.ConnectorsApiFp)(this.configuration).createCustomConnector(requestParameters.v3CreateConnectorDto, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Delete a custom connector that using its script name. A token with ORG_ADMIN authority is required to call this API.
		     * @param {ConnectorsApiDeleteCustomConnectorRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof ConnectorsApi
		     */
		    ConnectorsApi.prototype.deleteCustomConnector = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.ConnectorsApiFp)(this.configuration).deleteCustomConnector(requestParameters.scriptName, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Fetches a connector that using its script name. A token with ORG_ADMIN authority is required to call this API.
		     * @param {ConnectorsApiGetConnectorRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof ConnectorsApi
		     */
		    ConnectorsApi.prototype.getConnector = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.ConnectorsApiFp)(this.configuration).getConnector(requestParameters.scriptName, requestParameters.locale, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Fetches a connector\'s correlation config using its script name. A token with ORG_ADMIN authority is required to call this API.
		     * @param {ConnectorsApiGetConnectorCorrelationConfigRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof ConnectorsApi
		     */
		    ConnectorsApi.prototype.getConnectorCorrelationConfig = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.ConnectorsApiFp)(this.configuration).getConnectorCorrelationConfig(requestParameters.scriptName, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Fetches a connector\'s source config using its script name. A token with ORG_ADMIN authority is required to call this API.
		     * @param {ConnectorsApiGetConnectorSourceConfigRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof ConnectorsApi
		     */
		    ConnectorsApi.prototype.getConnectorSourceConfig = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.ConnectorsApiFp)(this.configuration).getConnectorSourceConfig(requestParameters.scriptName, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Fetches a connector\'s source template using its script name. A token with ORG_ADMIN authority is required to call this API.
		     * @param {ConnectorsApiGetConnectorSourceTemplateRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof ConnectorsApi
		     */
		    ConnectorsApi.prototype.getConnectorSourceTemplate = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.ConnectorsApiFp)(this.configuration).getConnectorSourceTemplate(requestParameters.scriptName, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Fetches a connector\'s translations using its script name. A token with ORG_ADMIN authority is required to call this API.
		     * @param {ConnectorsApiGetConnectorTranslationsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof ConnectorsApi
		     */
		    ConnectorsApi.prototype.getConnectorTranslations = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.ConnectorsApiFp)(this.configuration).getConnectorTranslations(requestParameters.scriptName, requestParameters.locale, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Update a connector\'s correlation config using its script name. A token with ORG_ADMIN authority is required to call this API.
		     * @param {ConnectorsApiPutCorrelationConfigRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof ConnectorsApi
		     */
		    ConnectorsApi.prototype.putCorrelationConfig = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.ConnectorsApiFp)(this.configuration).putCorrelationConfig(requestParameters.scriptName, requestParameters.file, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Update a connector\'s source config using its script name. A token with ORG_ADMIN authority is required to call this API.
		     * @param {ConnectorsApiPutSourceConfigRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof ConnectorsApi
		     */
		    ConnectorsApi.prototype.putSourceConfig = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.ConnectorsApiFp)(this.configuration).putSourceConfig(requestParameters.scriptName, requestParameters.file, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Update a connector\'s source template using its script name. A token with ORG_ADMIN authority is required to call this API.
		     * @param {ConnectorsApiPutSourceTemplateRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof ConnectorsApi
		     */
		    ConnectorsApi.prototype.putSourceTemplate = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.ConnectorsApiFp)(this.configuration).putSourceTemplate(requestParameters.scriptName, requestParameters.file, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Update a connector\'s translations using its script name. A token with ORG_ADMIN authority is required to call this API.
		     * @param {ConnectorsApiPutTranslationsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof ConnectorsApi
		     */
		    ConnectorsApi.prototype.putTranslations = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.ConnectorsApiFp)(this.configuration).putTranslations(requestParameters.scriptName, requestParameters.locale, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Patch a custom connector that using its script name. A token with ORG_ADMIN authority is required to call this API. The following fields are patchable: * connectorMetadata * applicationXml * correlationConfigXml * sourceConfigXml
		     * @param {ConnectorsApiUpdateConnectorRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof ConnectorsApi
		     */
		    ConnectorsApi.prototype.updateConnector = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.ConnectorsApiFp)(this.configuration).updateConnector(requestParameters.scriptName, requestParameters.jsonPatchOperation, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return ConnectorsApi;
		}(base_1.BaseAPI));
		exports.ConnectorsApi = ConnectorsApi;
		/**
		 * GlobalTenantSecuritySettingsApi - axios parameter creator
		 * @export
		 */
		var GlobalTenantSecuritySettingsApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * This API returns the details of an org\'s network auth configuration. Requires security scope of: \'sp:auth-org:create\'
		         * @summary Create security network configuration.
		         * @param {NetworkConfiguration} networkConfiguration Network configuration creation request body.   The following constraints ensure the request body conforms to certain logical guidelines, which are:   1. Each string element in the range array must be a valid ip address or ip subnet mask.   2. Each string element in the geolocation array must be 2 characters, and they can only be uppercase letters.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createAuthOrgNetworkConfig: function (networkConfiguration, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'networkConfiguration' is not null or undefined
		                            (0, common_1.assertParamExists)('createAuthOrgNetworkConfig', 'networkConfiguration', networkConfiguration);
		                            localVarPath = "/auth-org/network-config";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(networkConfiguration, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns the details of an org\'s network auth configuration. Requires security scope of: \'sp:auth-org:read\'
		         * @summary Get security network configuration.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getAuthOrgNetworkConfig: function (axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/auth-org/network-config";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API updates an existing network configuration for an org using PATCH  Requires security scope of:  \'sp:auth-org:update\'
		         * @summary Update security network configuration.
		         * @param {Array<JsonPatchOperation>} jsonPatchOperation A list of auth org network configuration update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard. Ensures that the patched Network Config conforms to certain logical guidelines, which are:   1. Each string element in the range array must be a valid ip address or ip subnet mask.   2. Each string element in the geolocation array must be 2 characters, and they can only be uppercase letters.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchAuthOrgNetworkConfig: function (jsonPatchOperation, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'jsonPatchOperation' is not null or undefined
		                            (0, common_1.assertParamExists)('patchAuthOrgNetworkConfig', 'jsonPatchOperation', jsonPatchOperation);
		                            localVarPath = "/auth-org/network-config";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PATCH' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json-patch+json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(jsonPatchOperation, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.GlobalTenantSecuritySettingsApiAxiosParamCreator = GlobalTenantSecuritySettingsApiAxiosParamCreator;
		/**
		 * GlobalTenantSecuritySettingsApi - functional programming interface
		 * @export
		 */
		var GlobalTenantSecuritySettingsApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.GlobalTenantSecuritySettingsApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * This API returns the details of an org\'s network auth configuration. Requires security scope of: \'sp:auth-org:create\'
		         * @summary Create security network configuration.
		         * @param {NetworkConfiguration} networkConfiguration Network configuration creation request body.   The following constraints ensure the request body conforms to certain logical guidelines, which are:   1. Each string element in the range array must be a valid ip address or ip subnet mask.   2. Each string element in the geolocation array must be 2 characters, and they can only be uppercase letters.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createAuthOrgNetworkConfig: function (networkConfiguration, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.createAuthOrgNetworkConfig(networkConfiguration, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns the details of an org\'s network auth configuration. Requires security scope of: \'sp:auth-org:read\'
		         * @summary Get security network configuration.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getAuthOrgNetworkConfig: function (axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getAuthOrgNetworkConfig(axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API updates an existing network configuration for an org using PATCH  Requires security scope of:  \'sp:auth-org:update\'
		         * @summary Update security network configuration.
		         * @param {Array<JsonPatchOperation>} jsonPatchOperation A list of auth org network configuration update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard. Ensures that the patched Network Config conforms to certain logical guidelines, which are:   1. Each string element in the range array must be a valid ip address or ip subnet mask.   2. Each string element in the geolocation array must be 2 characters, and they can only be uppercase letters.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchAuthOrgNetworkConfig: function (jsonPatchOperation, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.patchAuthOrgNetworkConfig(jsonPatchOperation, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.GlobalTenantSecuritySettingsApiFp = GlobalTenantSecuritySettingsApiFp;
		/**
		 * GlobalTenantSecuritySettingsApi - factory interface
		 * @export
		 */
		var GlobalTenantSecuritySettingsApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.GlobalTenantSecuritySettingsApiFp)(configuration);
		    return {
		        /**
		         * This API returns the details of an org\'s network auth configuration. Requires security scope of: \'sp:auth-org:create\'
		         * @summary Create security network configuration.
		         * @param {NetworkConfiguration} networkConfiguration Network configuration creation request body.   The following constraints ensure the request body conforms to certain logical guidelines, which are:   1. Each string element in the range array must be a valid ip address or ip subnet mask.   2. Each string element in the geolocation array must be 2 characters, and they can only be uppercase letters.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createAuthOrgNetworkConfig: function (networkConfiguration, axiosOptions) {
		            return localVarFp.createAuthOrgNetworkConfig(networkConfiguration, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API returns the details of an org\'s network auth configuration. Requires security scope of: \'sp:auth-org:read\'
		         * @summary Get security network configuration.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getAuthOrgNetworkConfig: function (axiosOptions) {
		            return localVarFp.getAuthOrgNetworkConfig(axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API updates an existing network configuration for an org using PATCH  Requires security scope of:  \'sp:auth-org:update\'
		         * @summary Update security network configuration.
		         * @param {Array<JsonPatchOperation>} jsonPatchOperation A list of auth org network configuration update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard. Ensures that the patched Network Config conforms to certain logical guidelines, which are:   1. Each string element in the range array must be a valid ip address or ip subnet mask.   2. Each string element in the geolocation array must be 2 characters, and they can only be uppercase letters.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchAuthOrgNetworkConfig: function (jsonPatchOperation, axiosOptions) {
		            return localVarFp.patchAuthOrgNetworkConfig(jsonPatchOperation, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.GlobalTenantSecuritySettingsApiFactory = GlobalTenantSecuritySettingsApiFactory;
		/**
		 * GlobalTenantSecuritySettingsApi - object-oriented interface
		 * @export
		 * @class GlobalTenantSecuritySettingsApi
		 * @extends {BaseAPI}
		 */
		var GlobalTenantSecuritySettingsApi = /** @class */ (function (_super) {
		    __extends(GlobalTenantSecuritySettingsApi, _super);
		    function GlobalTenantSecuritySettingsApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * This API returns the details of an org\'s network auth configuration. Requires security scope of: \'sp:auth-org:create\'
		     * @summary Create security network configuration.
		     * @param {GlobalTenantSecuritySettingsApiCreateAuthOrgNetworkConfigRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof GlobalTenantSecuritySettingsApi
		     */
		    GlobalTenantSecuritySettingsApi.prototype.createAuthOrgNetworkConfig = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.GlobalTenantSecuritySettingsApiFp)(this.configuration).createAuthOrgNetworkConfig(requestParameters.networkConfiguration, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API returns the details of an org\'s network auth configuration. Requires security scope of: \'sp:auth-org:read\'
		     * @summary Get security network configuration.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof GlobalTenantSecuritySettingsApi
		     */
		    GlobalTenantSecuritySettingsApi.prototype.getAuthOrgNetworkConfig = function (axiosOptions) {
		        var _this = this;
		        return (0, exports.GlobalTenantSecuritySettingsApiFp)(this.configuration).getAuthOrgNetworkConfig(axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API updates an existing network configuration for an org using PATCH  Requires security scope of:  \'sp:auth-org:update\'
		     * @summary Update security network configuration.
		     * @param {GlobalTenantSecuritySettingsApiPatchAuthOrgNetworkConfigRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof GlobalTenantSecuritySettingsApi
		     */
		    GlobalTenantSecuritySettingsApi.prototype.patchAuthOrgNetworkConfig = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.GlobalTenantSecuritySettingsApiFp)(this.configuration).patchAuthOrgNetworkConfig(requestParameters.jsonPatchOperation, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return GlobalTenantSecuritySettingsApi;
		}(base_1.BaseAPI));
		exports.GlobalTenantSecuritySettingsApi = GlobalTenantSecuritySettingsApi;
		/**
		 * IdentityProfilesApi - axios parameter creator
		 * @export
		 */
		var IdentityProfilesApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * This deletes an Identity Profile based on ID.  On success, this endpoint will return a reference to the bulk delete task result.  A token with ORG_ADMIN authority is required to call this API.  The following rights are required to access this endpoint: idn:identity-profile:delete
		         * @summary Delete an Identity Profile
		         * @param {string} identityProfileId The Identity Profile ID.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteIdentityProfile: function (identityProfileId, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'identityProfileId' is not null or undefined
		                            (0, common_1.assertParamExists)('deleteIdentityProfile', 'identityProfileId', identityProfileId);
		                            localVarPath = "/identity-profiles/{identity-profile-id}"
		                                .replace("{".concat("identity-profile-id", "}"), encodeURIComponent(String(identityProfileId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'DELETE' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This deletes multiple Identity Profiles via a list of supplied IDs.  On success, this endpoint will return a reference to the bulk delete task result.  A token with ORG_ADMIN authority is required to call this API.  The following rights are required to access this endpoint: idn:identity-profile:delete
		         * @summary Delete Identity Profiles
		         * @param {Array<string>} requestBody Identity Profile bulk delete request body.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteIdentityProfiles: function (requestBody, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'requestBody' is not null or undefined
		                            (0, common_1.assertParamExists)('deleteIdentityProfiles', 'requestBody', requestBody);
		                            localVarPath = "/identity-profiles/bulk-delete";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(requestBody, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This exports existing identity profiles in the format specified by the sp-config service.
		         * @summary Export Identity Profiles
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, ne*  **name**: *eq, ne*  **priority**: *eq, ne*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **id, name, priority**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        exportIdentityProfiles: function (limit, offset, count, filters, sorters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/identity-profiles/export";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This returns the default identity attribute config. A token with ORG_ADMIN authority is required to call this API to get the default identity attribute config.
		         * @summary Get default Identity Attribute Config
		         * @param {string} identityProfileId The Identity Profile ID.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getDefaultIdentityAttributeConfig: function (identityProfileId, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'identityProfileId' is not null or undefined
		                            (0, common_1.assertParamExists)('getDefaultIdentityAttributeConfig', 'identityProfileId', identityProfileId);
		                            localVarPath = "/identity-profiles/{identity-profile-id}/default-identity-attribute-config"
		                                .replace("{".concat("identity-profile-id", "}"), encodeURIComponent(String(identityProfileId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This returns a single Identity Profile based on ID. A token with ORG_ADMIN or API authority is required to call this API.
		         * @summary Get single Identity Profile
		         * @param {string} identityProfileId The Identity Profile ID.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getIdentityProfile: function (identityProfileId, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'identityProfileId' is not null or undefined
		                            (0, common_1.assertParamExists)('getIdentityProfile', 'identityProfileId', identityProfileId);
		                            localVarPath = "/identity-profiles/{identity-profile-id}"
		                                .replace("{".concat("identity-profile-id", "}"), encodeURIComponent(String(identityProfileId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This imports previously exported identity profiles.
		         * @summary Import Identity Profiles
		         * @param {Array<IdentityProfileExportedObject>} identityProfileExportedObject Previously exported Identity Profiles.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        importIdentityProfiles: function (identityProfileExportedObject, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'identityProfileExportedObject' is not null or undefined
		                            (0, common_1.assertParamExists)('importIdentityProfiles', 'identityProfileExportedObject', identityProfileExportedObject);
		                            localVarPath = "/identity-profiles/import";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(identityProfileExportedObject, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This returns a list of Identity Profiles based on the specified query parameters. A token with ORG_ADMIN or API authority is required to call this API to get a list of Identity Profiles.
		         * @summary Identity Profiles List
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, ne, ge, gt, in, le, lt, isnull, sw*  **name**: *eq, ne, in, le, lt, isnull, sw*  **priority**: *eq, ne*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **id, name, priority, created, modified, owner.id, owner.name**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listIdentityProfiles: function (limit, offset, count, filters, sorters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/identity-profiles";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Process identities under the profile  A token with ORG_ADMIN authority is required to call this API.
		         * @summary Process identities under profile
		         * @param {string} identityProfileId The Identity Profile ID to be processed
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        syncIdentityProfile: function (identityProfileId, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'identityProfileId' is not null or undefined
		                            (0, common_1.assertParamExists)('syncIdentityProfile', 'identityProfileId', identityProfileId);
		                            localVarPath = "/identity-profiles/{identity-profile-id}/process-identities"
		                                .replace("{".concat("identity-profile-id", "}"), encodeURIComponent(String(identityProfileId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.IdentityProfilesApiAxiosParamCreator = IdentityProfilesApiAxiosParamCreator;
		/**
		 * IdentityProfilesApi - functional programming interface
		 * @export
		 */
		var IdentityProfilesApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.IdentityProfilesApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * This deletes an Identity Profile based on ID.  On success, this endpoint will return a reference to the bulk delete task result.  A token with ORG_ADMIN authority is required to call this API.  The following rights are required to access this endpoint: idn:identity-profile:delete
		         * @summary Delete an Identity Profile
		         * @param {string} identityProfileId The Identity Profile ID.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteIdentityProfile: function (identityProfileId, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.deleteIdentityProfile(identityProfileId, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This deletes multiple Identity Profiles via a list of supplied IDs.  On success, this endpoint will return a reference to the bulk delete task result.  A token with ORG_ADMIN authority is required to call this API.  The following rights are required to access this endpoint: idn:identity-profile:delete
		         * @summary Delete Identity Profiles
		         * @param {Array<string>} requestBody Identity Profile bulk delete request body.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteIdentityProfiles: function (requestBody, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.deleteIdentityProfiles(requestBody, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This exports existing identity profiles in the format specified by the sp-config service.
		         * @summary Export Identity Profiles
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, ne*  **name**: *eq, ne*  **priority**: *eq, ne*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **id, name, priority**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        exportIdentityProfiles: function (limit, offset, count, filters, sorters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.exportIdentityProfiles(limit, offset, count, filters, sorters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This returns the default identity attribute config. A token with ORG_ADMIN authority is required to call this API to get the default identity attribute config.
		         * @summary Get default Identity Attribute Config
		         * @param {string} identityProfileId The Identity Profile ID.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getDefaultIdentityAttributeConfig: function (identityProfileId, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getDefaultIdentityAttributeConfig(identityProfileId, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This returns a single Identity Profile based on ID. A token with ORG_ADMIN or API authority is required to call this API.
		         * @summary Get single Identity Profile
		         * @param {string} identityProfileId The Identity Profile ID.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getIdentityProfile: function (identityProfileId, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getIdentityProfile(identityProfileId, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This imports previously exported identity profiles.
		         * @summary Import Identity Profiles
		         * @param {Array<IdentityProfileExportedObject>} identityProfileExportedObject Previously exported Identity Profiles.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        importIdentityProfiles: function (identityProfileExportedObject, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.importIdentityProfiles(identityProfileExportedObject, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This returns a list of Identity Profiles based on the specified query parameters. A token with ORG_ADMIN or API authority is required to call this API to get a list of Identity Profiles.
		         * @summary Identity Profiles List
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, ne, ge, gt, in, le, lt, isnull, sw*  **name**: *eq, ne, in, le, lt, isnull, sw*  **priority**: *eq, ne*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **id, name, priority, created, modified, owner.id, owner.name**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listIdentityProfiles: function (limit, offset, count, filters, sorters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listIdentityProfiles(limit, offset, count, filters, sorters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Process identities under the profile  A token with ORG_ADMIN authority is required to call this API.
		         * @summary Process identities under profile
		         * @param {string} identityProfileId The Identity Profile ID to be processed
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        syncIdentityProfile: function (identityProfileId, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.syncIdentityProfile(identityProfileId, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.IdentityProfilesApiFp = IdentityProfilesApiFp;
		/**
		 * IdentityProfilesApi - factory interface
		 * @export
		 */
		var IdentityProfilesApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.IdentityProfilesApiFp)(configuration);
		    return {
		        /**
		         * This deletes an Identity Profile based on ID.  On success, this endpoint will return a reference to the bulk delete task result.  A token with ORG_ADMIN authority is required to call this API.  The following rights are required to access this endpoint: idn:identity-profile:delete
		         * @summary Delete an Identity Profile
		         * @param {string} identityProfileId The Identity Profile ID.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteIdentityProfile: function (identityProfileId, axiosOptions) {
		            return localVarFp.deleteIdentityProfile(identityProfileId, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This deletes multiple Identity Profiles via a list of supplied IDs.  On success, this endpoint will return a reference to the bulk delete task result.  A token with ORG_ADMIN authority is required to call this API.  The following rights are required to access this endpoint: idn:identity-profile:delete
		         * @summary Delete Identity Profiles
		         * @param {Array<string>} requestBody Identity Profile bulk delete request body.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteIdentityProfiles: function (requestBody, axiosOptions) {
		            return localVarFp.deleteIdentityProfiles(requestBody, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This exports existing identity profiles in the format specified by the sp-config service.
		         * @summary Export Identity Profiles
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, ne*  **name**: *eq, ne*  **priority**: *eq, ne*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **id, name, priority**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        exportIdentityProfiles: function (limit, offset, count, filters, sorters, axiosOptions) {
		            return localVarFp.exportIdentityProfiles(limit, offset, count, filters, sorters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This returns the default identity attribute config. A token with ORG_ADMIN authority is required to call this API to get the default identity attribute config.
		         * @summary Get default Identity Attribute Config
		         * @param {string} identityProfileId The Identity Profile ID.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getDefaultIdentityAttributeConfig: function (identityProfileId, axiosOptions) {
		            return localVarFp.getDefaultIdentityAttributeConfig(identityProfileId, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This returns a single Identity Profile based on ID. A token with ORG_ADMIN or API authority is required to call this API.
		         * @summary Get single Identity Profile
		         * @param {string} identityProfileId The Identity Profile ID.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getIdentityProfile: function (identityProfileId, axiosOptions) {
		            return localVarFp.getIdentityProfile(identityProfileId, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This imports previously exported identity profiles.
		         * @summary Import Identity Profiles
		         * @param {Array<IdentityProfileExportedObject>} identityProfileExportedObject Previously exported Identity Profiles.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        importIdentityProfiles: function (identityProfileExportedObject, axiosOptions) {
		            return localVarFp.importIdentityProfiles(identityProfileExportedObject, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This returns a list of Identity Profiles based on the specified query parameters. A token with ORG_ADMIN or API authority is required to call this API to get a list of Identity Profiles.
		         * @summary Identity Profiles List
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, ne, ge, gt, in, le, lt, isnull, sw*  **name**: *eq, ne, in, le, lt, isnull, sw*  **priority**: *eq, ne*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **id, name, priority, created, modified, owner.id, owner.name**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listIdentityProfiles: function (limit, offset, count, filters, sorters, axiosOptions) {
		            return localVarFp.listIdentityProfiles(limit, offset, count, filters, sorters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Process identities under the profile  A token with ORG_ADMIN authority is required to call this API.
		         * @summary Process identities under profile
		         * @param {string} identityProfileId The Identity Profile ID to be processed
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        syncIdentityProfile: function (identityProfileId, axiosOptions) {
		            return localVarFp.syncIdentityProfile(identityProfileId, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.IdentityProfilesApiFactory = IdentityProfilesApiFactory;
		/**
		 * IdentityProfilesApi - object-oriented interface
		 * @export
		 * @class IdentityProfilesApi
		 * @extends {BaseAPI}
		 */
		var IdentityProfilesApi = /** @class */ (function (_super) {
		    __extends(IdentityProfilesApi, _super);
		    function IdentityProfilesApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * This deletes an Identity Profile based on ID.  On success, this endpoint will return a reference to the bulk delete task result.  A token with ORG_ADMIN authority is required to call this API.  The following rights are required to access this endpoint: idn:identity-profile:delete
		     * @summary Delete an Identity Profile
		     * @param {IdentityProfilesApiDeleteIdentityProfileRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IdentityProfilesApi
		     */
		    IdentityProfilesApi.prototype.deleteIdentityProfile = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.IdentityProfilesApiFp)(this.configuration).deleteIdentityProfile(requestParameters.identityProfileId, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This deletes multiple Identity Profiles via a list of supplied IDs.  On success, this endpoint will return a reference to the bulk delete task result.  A token with ORG_ADMIN authority is required to call this API.  The following rights are required to access this endpoint: idn:identity-profile:delete
		     * @summary Delete Identity Profiles
		     * @param {IdentityProfilesApiDeleteIdentityProfilesRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IdentityProfilesApi
		     */
		    IdentityProfilesApi.prototype.deleteIdentityProfiles = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.IdentityProfilesApiFp)(this.configuration).deleteIdentityProfiles(requestParameters.requestBody, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This exports existing identity profiles in the format specified by the sp-config service.
		     * @summary Export Identity Profiles
		     * @param {IdentityProfilesApiExportIdentityProfilesRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IdentityProfilesApi
		     */
		    IdentityProfilesApi.prototype.exportIdentityProfiles = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.IdentityProfilesApiFp)(this.configuration).exportIdentityProfiles(requestParameters.limit, requestParameters.offset, requestParameters.count, requestParameters.filters, requestParameters.sorters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This returns the default identity attribute config. A token with ORG_ADMIN authority is required to call this API to get the default identity attribute config.
		     * @summary Get default Identity Attribute Config
		     * @param {IdentityProfilesApiGetDefaultIdentityAttributeConfigRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IdentityProfilesApi
		     */
		    IdentityProfilesApi.prototype.getDefaultIdentityAttributeConfig = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.IdentityProfilesApiFp)(this.configuration).getDefaultIdentityAttributeConfig(requestParameters.identityProfileId, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This returns a single Identity Profile based on ID. A token with ORG_ADMIN or API authority is required to call this API.
		     * @summary Get single Identity Profile
		     * @param {IdentityProfilesApiGetIdentityProfileRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IdentityProfilesApi
		     */
		    IdentityProfilesApi.prototype.getIdentityProfile = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.IdentityProfilesApiFp)(this.configuration).getIdentityProfile(requestParameters.identityProfileId, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This imports previously exported identity profiles.
		     * @summary Import Identity Profiles
		     * @param {IdentityProfilesApiImportIdentityProfilesRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IdentityProfilesApi
		     */
		    IdentityProfilesApi.prototype.importIdentityProfiles = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.IdentityProfilesApiFp)(this.configuration).importIdentityProfiles(requestParameters.identityProfileExportedObject, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This returns a list of Identity Profiles based on the specified query parameters. A token with ORG_ADMIN or API authority is required to call this API to get a list of Identity Profiles.
		     * @summary Identity Profiles List
		     * @param {IdentityProfilesApiListIdentityProfilesRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IdentityProfilesApi
		     */
		    IdentityProfilesApi.prototype.listIdentityProfiles = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.IdentityProfilesApiFp)(this.configuration).listIdentityProfiles(requestParameters.limit, requestParameters.offset, requestParameters.count, requestParameters.filters, requestParameters.sorters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Process identities under the profile  A token with ORG_ADMIN authority is required to call this API.
		     * @summary Process identities under profile
		     * @param {IdentityProfilesApiSyncIdentityProfileRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof IdentityProfilesApi
		     */
		    IdentityProfilesApi.prototype.syncIdentityProfile = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.IdentityProfilesApiFp)(this.configuration).syncIdentityProfile(requestParameters.identityProfileId, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return IdentityProfilesApi;
		}(base_1.BaseAPI));
		exports.IdentityProfilesApi = IdentityProfilesApi;
		/**
		 * LifecycleStatesApi - axios parameter creator
		 * @export
		 */
		var LifecycleStatesApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * This API creates a new Lifecycle State. A token with ORG_ADMIN or API authority is required to call this API.
		         * @summary Create Lifecycle State
		         * @param {string} identityProfileId Identity Profile ID
		         * @param {LifecycleState} lifecycleState Lifecycle State
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createLifecycleState: function (identityProfileId, lifecycleState, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'identityProfileId' is not null or undefined
		                            (0, common_1.assertParamExists)('createLifecycleState', 'identityProfileId', identityProfileId);
		                            // verify required parameter 'lifecycleState' is not null or undefined
		                            (0, common_1.assertParamExists)('createLifecycleState', 'lifecycleState', lifecycleState);
		                            localVarPath = "/identity-profiles/{identity-profile-id}/lifecycle-states"
		                                .replace("{".concat("identity-profile-id", "}"), encodeURIComponent(String(identityProfileId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(lifecycleState, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This endpoint deletes the Lifecycle State using its ID. A token with API, or ORG_ADMIN authority is required to call this API.
		         * @summary Delete Lifecycle State by ID
		         * @param {string} identityProfileId Identity Profile ID
		         * @param {string} lifecycleStateId Lifecycle State ID
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteLifecycleState: function (identityProfileId, lifecycleStateId, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'identityProfileId' is not null or undefined
		                            (0, common_1.assertParamExists)('deleteLifecycleState', 'identityProfileId', identityProfileId);
		                            // verify required parameter 'lifecycleStateId' is not null or undefined
		                            (0, common_1.assertParamExists)('deleteLifecycleState', 'lifecycleStateId', lifecycleStateId);
		                            localVarPath = "/identity-profiles/{identity-profile-id}/lifecycle-states/{lifecycle-state-id}"
		                                .replace("{".concat("identity-profile-id", "}"), encodeURIComponent(String(identityProfileId)))
		                                .replace("{".concat("lifecycle-state-id", "}"), encodeURIComponent(String(lifecycleStateId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'DELETE' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This endpoint retrieves a Lifecycle State. A token with ORG_ADMIN or API authority is required to call this API.
		         * @summary Retrieves Lifecycle State
		         * @param {string} identityProfileId Identity Profile ID
		         * @param {string} lifecycleStateId Lifecycle State ID
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getLifecycleState: function (identityProfileId, lifecycleStateId, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'identityProfileId' is not null or undefined
		                            (0, common_1.assertParamExists)('getLifecycleState', 'identityProfileId', identityProfileId);
		                            // verify required parameter 'lifecycleStateId' is not null or undefined
		                            (0, common_1.assertParamExists)('getLifecycleState', 'lifecycleStateId', lifecycleStateId);
		                            localVarPath = "/identity-profiles/{identity-profile-id}/lifecycle-states/{lifecycle-state-id}"
		                                .replace("{".concat("identity-profile-id", "}"), encodeURIComponent(String(identityProfileId)))
		                                .replace("{".concat("lifecycle-state-id", "}"), encodeURIComponent(String(lifecycleStateId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This end-point lists all the LifecycleStates associated with IdentityProfiles. A token with API, or ORG_ADMIN authority is required to call this API.
		         * @summary Lists LifecycleStates
		         * @param {string} identityProfileId The IdentityProfile id
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **created, modified**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listLifecycleStates: function (identityProfileId, limit, offset, count, sorters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'identityProfileId' is not null or undefined
		                            (0, common_1.assertParamExists)('listLifecycleStates', 'identityProfileId', identityProfileId);
		                            localVarPath = "/identity-profiles/{identity-profile-id}/lifecycle-states"
		                                .replace("{".concat("identity-profile-id", "}"), encodeURIComponent(String(identityProfileId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This endpoint will set/update an identity\'s lifecycle state to the one provided and updates the corresponding Identity Profile. A token with ORG_ADMIN or API authority is required to call this API.
		         * @summary Set Lifecycle State
		         * @param {string} identityId The ID of the identity to update
		         * @param {SetLifecycleStateRequest} setLifecycleStateRequest
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        setLifecycleState: function (identityId, setLifecycleStateRequest, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'identityId' is not null or undefined
		                            (0, common_1.assertParamExists)('setLifecycleState', 'identityId', identityId);
		                            // verify required parameter 'setLifecycleStateRequest' is not null or undefined
		                            (0, common_1.assertParamExists)('setLifecycleState', 'setLifecycleStateRequest', setLifecycleStateRequest);
		                            localVarPath = "/identities/{identity-id}/set-lifecycle-state"
		                                .replace("{".concat("identity-id", "}"), encodeURIComponent(String(identityId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(setLifecycleStateRequest, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This endpoint updates individual Lifecycle State fields using the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard. A token with ORG_ADMIN or API authority is required to call this API.
		         * @summary Update Lifecycle State
		         * @param {string} identityProfileId Identity Profile ID
		         * @param {string} lifecycleStateId Lifecycle State ID
		         * @param {Array<JsonPatchOperation>} jsonPatchOperation A list of lifecycle state update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.  The following fields can be updated: * enabled * description * accountActions * accessProfileIds * emailNotificationOption
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateLifecycleStates: function (identityProfileId, lifecycleStateId, jsonPatchOperation, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'identityProfileId' is not null or undefined
		                            (0, common_1.assertParamExists)('updateLifecycleStates', 'identityProfileId', identityProfileId);
		                            // verify required parameter 'lifecycleStateId' is not null or undefined
		                            (0, common_1.assertParamExists)('updateLifecycleStates', 'lifecycleStateId', lifecycleStateId);
		                            // verify required parameter 'jsonPatchOperation' is not null or undefined
		                            (0, common_1.assertParamExists)('updateLifecycleStates', 'jsonPatchOperation', jsonPatchOperation);
		                            localVarPath = "/identity-profiles/{identity-profile-id}/lifecycle-states/{lifecycle-state-id}"
		                                .replace("{".concat("identity-profile-id", "}"), encodeURIComponent(String(identityProfileId)))
		                                .replace("{".concat("lifecycle-state-id", "}"), encodeURIComponent(String(lifecycleStateId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PATCH' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json-patch+json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(jsonPatchOperation, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.LifecycleStatesApiAxiosParamCreator = LifecycleStatesApiAxiosParamCreator;
		/**
		 * LifecycleStatesApi - functional programming interface
		 * @export
		 */
		var LifecycleStatesApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.LifecycleStatesApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * This API creates a new Lifecycle State. A token with ORG_ADMIN or API authority is required to call this API.
		         * @summary Create Lifecycle State
		         * @param {string} identityProfileId Identity Profile ID
		         * @param {LifecycleState} lifecycleState Lifecycle State
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createLifecycleState: function (identityProfileId, lifecycleState, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.createLifecycleState(identityProfileId, lifecycleState, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This endpoint deletes the Lifecycle State using its ID. A token with API, or ORG_ADMIN authority is required to call this API.
		         * @summary Delete Lifecycle State by ID
		         * @param {string} identityProfileId Identity Profile ID
		         * @param {string} lifecycleStateId Lifecycle State ID
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteLifecycleState: function (identityProfileId, lifecycleStateId, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.deleteLifecycleState(identityProfileId, lifecycleStateId, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This endpoint retrieves a Lifecycle State. A token with ORG_ADMIN or API authority is required to call this API.
		         * @summary Retrieves Lifecycle State
		         * @param {string} identityProfileId Identity Profile ID
		         * @param {string} lifecycleStateId Lifecycle State ID
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getLifecycleState: function (identityProfileId, lifecycleStateId, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getLifecycleState(identityProfileId, lifecycleStateId, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This end-point lists all the LifecycleStates associated with IdentityProfiles. A token with API, or ORG_ADMIN authority is required to call this API.
		         * @summary Lists LifecycleStates
		         * @param {string} identityProfileId The IdentityProfile id
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **created, modified**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listLifecycleStates: function (identityProfileId, limit, offset, count, sorters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listLifecycleStates(identityProfileId, limit, offset, count, sorters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This endpoint will set/update an identity\'s lifecycle state to the one provided and updates the corresponding Identity Profile. A token with ORG_ADMIN or API authority is required to call this API.
		         * @summary Set Lifecycle State
		         * @param {string} identityId The ID of the identity to update
		         * @param {SetLifecycleStateRequest} setLifecycleStateRequest
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        setLifecycleState: function (identityId, setLifecycleStateRequest, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.setLifecycleState(identityId, setLifecycleStateRequest, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This endpoint updates individual Lifecycle State fields using the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard. A token with ORG_ADMIN or API authority is required to call this API.
		         * @summary Update Lifecycle State
		         * @param {string} identityProfileId Identity Profile ID
		         * @param {string} lifecycleStateId Lifecycle State ID
		         * @param {Array<JsonPatchOperation>} jsonPatchOperation A list of lifecycle state update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.  The following fields can be updated: * enabled * description * accountActions * accessProfileIds * emailNotificationOption
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateLifecycleStates: function (identityProfileId, lifecycleStateId, jsonPatchOperation, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.updateLifecycleStates(identityProfileId, lifecycleStateId, jsonPatchOperation, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.LifecycleStatesApiFp = LifecycleStatesApiFp;
		/**
		 * LifecycleStatesApi - factory interface
		 * @export
		 */
		var LifecycleStatesApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.LifecycleStatesApiFp)(configuration);
		    return {
		        /**
		         * This API creates a new Lifecycle State. A token with ORG_ADMIN or API authority is required to call this API.
		         * @summary Create Lifecycle State
		         * @param {string} identityProfileId Identity Profile ID
		         * @param {LifecycleState} lifecycleState Lifecycle State
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createLifecycleState: function (identityProfileId, lifecycleState, axiosOptions) {
		            return localVarFp.createLifecycleState(identityProfileId, lifecycleState, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This endpoint deletes the Lifecycle State using its ID. A token with API, or ORG_ADMIN authority is required to call this API.
		         * @summary Delete Lifecycle State by ID
		         * @param {string} identityProfileId Identity Profile ID
		         * @param {string} lifecycleStateId Lifecycle State ID
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteLifecycleState: function (identityProfileId, lifecycleStateId, axiosOptions) {
		            return localVarFp.deleteLifecycleState(identityProfileId, lifecycleStateId, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This endpoint retrieves a Lifecycle State. A token with ORG_ADMIN or API authority is required to call this API.
		         * @summary Retrieves Lifecycle State
		         * @param {string} identityProfileId Identity Profile ID
		         * @param {string} lifecycleStateId Lifecycle State ID
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getLifecycleState: function (identityProfileId, lifecycleStateId, axiosOptions) {
		            return localVarFp.getLifecycleState(identityProfileId, lifecycleStateId, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This end-point lists all the LifecycleStates associated with IdentityProfiles. A token with API, or ORG_ADMIN authority is required to call this API.
		         * @summary Lists LifecycleStates
		         * @param {string} identityProfileId The IdentityProfile id
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **created, modified**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listLifecycleStates: function (identityProfileId, limit, offset, count, sorters, axiosOptions) {
		            return localVarFp.listLifecycleStates(identityProfileId, limit, offset, count, sorters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This endpoint will set/update an identity\'s lifecycle state to the one provided and updates the corresponding Identity Profile. A token with ORG_ADMIN or API authority is required to call this API.
		         * @summary Set Lifecycle State
		         * @param {string} identityId The ID of the identity to update
		         * @param {SetLifecycleStateRequest} setLifecycleStateRequest
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        setLifecycleState: function (identityId, setLifecycleStateRequest, axiosOptions) {
		            return localVarFp.setLifecycleState(identityId, setLifecycleStateRequest, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This endpoint updates individual Lifecycle State fields using the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard. A token with ORG_ADMIN or API authority is required to call this API.
		         * @summary Update Lifecycle State
		         * @param {string} identityProfileId Identity Profile ID
		         * @param {string} lifecycleStateId Lifecycle State ID
		         * @param {Array<JsonPatchOperation>} jsonPatchOperation A list of lifecycle state update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.  The following fields can be updated: * enabled * description * accountActions * accessProfileIds * emailNotificationOption
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateLifecycleStates: function (identityProfileId, lifecycleStateId, jsonPatchOperation, axiosOptions) {
		            return localVarFp.updateLifecycleStates(identityProfileId, lifecycleStateId, jsonPatchOperation, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.LifecycleStatesApiFactory = LifecycleStatesApiFactory;
		/**
		 * LifecycleStatesApi - object-oriented interface
		 * @export
		 * @class LifecycleStatesApi
		 * @extends {BaseAPI}
		 */
		var LifecycleStatesApi = /** @class */ (function (_super) {
		    __extends(LifecycleStatesApi, _super);
		    function LifecycleStatesApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * This API creates a new Lifecycle State. A token with ORG_ADMIN or API authority is required to call this API.
		     * @summary Create Lifecycle State
		     * @param {LifecycleStatesApiCreateLifecycleStateRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof LifecycleStatesApi
		     */
		    LifecycleStatesApi.prototype.createLifecycleState = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.LifecycleStatesApiFp)(this.configuration).createLifecycleState(requestParameters.identityProfileId, requestParameters.lifecycleState, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This endpoint deletes the Lifecycle State using its ID. A token with API, or ORG_ADMIN authority is required to call this API.
		     * @summary Delete Lifecycle State by ID
		     * @param {LifecycleStatesApiDeleteLifecycleStateRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof LifecycleStatesApi
		     */
		    LifecycleStatesApi.prototype.deleteLifecycleState = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.LifecycleStatesApiFp)(this.configuration).deleteLifecycleState(requestParameters.identityProfileId, requestParameters.lifecycleStateId, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This endpoint retrieves a Lifecycle State. A token with ORG_ADMIN or API authority is required to call this API.
		     * @summary Retrieves Lifecycle State
		     * @param {LifecycleStatesApiGetLifecycleStateRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof LifecycleStatesApi
		     */
		    LifecycleStatesApi.prototype.getLifecycleState = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.LifecycleStatesApiFp)(this.configuration).getLifecycleState(requestParameters.identityProfileId, requestParameters.lifecycleStateId, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This end-point lists all the LifecycleStates associated with IdentityProfiles. A token with API, or ORG_ADMIN authority is required to call this API.
		     * @summary Lists LifecycleStates
		     * @param {LifecycleStatesApiListLifecycleStatesRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof LifecycleStatesApi
		     */
		    LifecycleStatesApi.prototype.listLifecycleStates = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.LifecycleStatesApiFp)(this.configuration).listLifecycleStates(requestParameters.identityProfileId, requestParameters.limit, requestParameters.offset, requestParameters.count, requestParameters.sorters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This endpoint will set/update an identity\'s lifecycle state to the one provided and updates the corresponding Identity Profile. A token with ORG_ADMIN or API authority is required to call this API.
		     * @summary Set Lifecycle State
		     * @param {LifecycleStatesApiSetLifecycleStateRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof LifecycleStatesApi
		     */
		    LifecycleStatesApi.prototype.setLifecycleState = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.LifecycleStatesApiFp)(this.configuration).setLifecycleState(requestParameters.identityId, requestParameters.setLifecycleStateRequest, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This endpoint updates individual Lifecycle State fields using the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard. A token with ORG_ADMIN or API authority is required to call this API.
		     * @summary Update Lifecycle State
		     * @param {LifecycleStatesApiUpdateLifecycleStatesRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof LifecycleStatesApi
		     */
		    LifecycleStatesApi.prototype.updateLifecycleStates = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.LifecycleStatesApiFp)(this.configuration).updateLifecycleStates(requestParameters.identityProfileId, requestParameters.lifecycleStateId, requestParameters.jsonPatchOperation, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return LifecycleStatesApi;
		}(base_1.BaseAPI));
		exports.LifecycleStatesApi = LifecycleStatesApi;
		/**
		 * NonEmployeeLifecycleManagementApi - axios parameter creator
		 * @export
		 */
		var NonEmployeeLifecycleManagementApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * Approves a non-employee approval request and notifies the next approver. The current user must be the requested approver.
		         * @summary Approve a Non-Employee Request
		         * @param {string} id Non-Employee approval item id (UUID)
		         * @param {NonEmployeeApprovalDecision} nonEmployeeApprovalDecision
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        approveNonEmployeeRequest: function (id, nonEmployeeApprovalDecision, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('approveNonEmployeeRequest', 'id', id);
		                            // verify required parameter 'nonEmployeeApprovalDecision' is not null or undefined
		                            (0, common_1.assertParamExists)('approveNonEmployeeRequest', 'nonEmployeeApprovalDecision', nonEmployeeApprovalDecision);
		                            localVarPath = "/non-employee-approvals/{id}/approve"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(nonEmployeeApprovalDecision, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This request will create a non-employee record. Requires role context of `idn:nesr:create`
		         * @summary Create Non-Employee Record
		         * @param {NonEmployeeRequestBody} nonEmployeeRequestBody Non-Employee record creation request body.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createNonEmployeeRecord: function (nonEmployeeRequestBody, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'nonEmployeeRequestBody' is not null or undefined
		                            (0, common_1.assertParamExists)('createNonEmployeeRecord', 'nonEmployeeRequestBody', nonEmployeeRequestBody);
		                            localVarPath = "/non-employee-records";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(nonEmployeeRequestBody, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This request will create a non-employee request and notify the approver. Requires role context of `idn:nesr:create` or the user must own the source.
		         * @summary Create Non-Employee Request
		         * @param {NonEmployeeRequestBody} nonEmployeeRequestBody Non-Employee creation request body
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createNonEmployeeRequest: function (nonEmployeeRequestBody, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'nonEmployeeRequestBody' is not null or undefined
		                            (0, common_1.assertParamExists)('createNonEmployeeRequest', 'nonEmployeeRequestBody', nonEmployeeRequestBody);
		                            localVarPath = "/non-employee-requests";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(nonEmployeeRequestBody, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This request will create a non-employee source. Requires role context of `idn:nesr:create`
		         * @summary Create Non-Employee Source
		         * @param {NonEmployeeSourceRequestBody} nonEmployeeSourceRequestBody Non-Employee source creation request body.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createNonEmployeeSource: function (nonEmployeeSourceRequestBody, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'nonEmployeeSourceRequestBody' is not null or undefined
		                            (0, common_1.assertParamExists)('createNonEmployeeSource', 'nonEmployeeSourceRequestBody', nonEmployeeSourceRequestBody);
		                            localVarPath = "/non-employee-sources";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(nonEmployeeSourceRequestBody, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API creates a new schema attribute for Non-Employee Source. The schema technical name must be unique in the source. Attempts to create a schema attribute with an existing name will result in a \"400.1.409 Reference conflict\" response. At most, 10 custom attributes can be created per schema. Attempts to create more than 10 will result in a \"400.1.4 Limit violation\" response. Requires role context of `idn:nesr:create`
		         * @summary Create a new Schema Attribute for Non-Employee Source
		         * @param {string} sourceId The Source id
		         * @param {NonEmployeeSchemaAttributeBody} nonEmployeeSchemaAttributeBody
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createNonEmployeeSourceSchemaAttributes: function (sourceId, nonEmployeeSchemaAttributeBody, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'sourceId' is not null or undefined
		                            (0, common_1.assertParamExists)('createNonEmployeeSourceSchemaAttributes', 'sourceId', sourceId);
		                            // verify required parameter 'nonEmployeeSchemaAttributeBody' is not null or undefined
		                            (0, common_1.assertParamExists)('createNonEmployeeSourceSchemaAttributes', 'nonEmployeeSchemaAttributeBody', nonEmployeeSchemaAttributeBody);
		                            localVarPath = "/non-employee-sources/{sourceId}/schema-attributes"
		                                .replace("{".concat("sourceId", "}"), encodeURIComponent(String(sourceId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(nonEmployeeSchemaAttributeBody, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This request will delete a non-employee record. Requires role context of `idn:nesr:delete`
		         * @summary Delete Non-Employee Record
		         * @param {string} id Non-Employee record id (UUID)
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteNonEmployeeRecord: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('deleteNonEmployeeRecord', 'id', id);
		                            localVarPath = "/non-employee-records/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'DELETE' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This request will delete multiple non-employee records based on the non-employee ids provided. Requires role context of `idn:nesr:delete`
		         * @summary Delete Multiple Non-Employee Records
		         * @param {DeleteNonEmployeeRecordsInBulkRequest} deleteNonEmployeeRecordsInBulkRequest Non-Employee bulk delete request body.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteNonEmployeeRecordsInBulk: function (deleteNonEmployeeRecordsInBulkRequest, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'deleteNonEmployeeRecordsInBulkRequest' is not null or undefined
		                            (0, common_1.assertParamExists)('deleteNonEmployeeRecordsInBulk', 'deleteNonEmployeeRecordsInBulkRequest', deleteNonEmployeeRecordsInBulkRequest);
		                            localVarPath = "/non-employee-records/bulk-delete";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(deleteNonEmployeeRecordsInBulkRequest, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This request will delete a non-employee request.  Requires role context of `idn:nesr:delete`
		         * @summary Delete Non-Employee Request
		         * @param {string} id Non-Employee request id in the UUID format
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteNonEmployeeRequest: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('deleteNonEmployeeRequest', 'id', id);
		                            localVarPath = "/non-employee-requests/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'DELETE' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This end-point deletes a specific schema attribute for a non-employee source. Requires role context of `idn:nesr:delete`
		         * @summary Delete a Schema Attribute for Non-Employee Source
		         * @param {string} attributeId The Schema Attribute Id (UUID)
		         * @param {string} sourceId The Source id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteNonEmployeeSchemaAttribute: function (attributeId, sourceId, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'attributeId' is not null or undefined
		                            (0, common_1.assertParamExists)('deleteNonEmployeeSchemaAttribute', 'attributeId', attributeId);
		                            // verify required parameter 'sourceId' is not null or undefined
		                            (0, common_1.assertParamExists)('deleteNonEmployeeSchemaAttribute', 'sourceId', sourceId);
		                            localVarPath = "/non-employee-sources/{sourceId}/schema-attributes/{attributeId}"
		                                .replace("{".concat("attributeId", "}"), encodeURIComponent(String(attributeId)))
		                                .replace("{".concat("sourceId", "}"), encodeURIComponent(String(sourceId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'DELETE' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This request will delete a non-employee source. Requires role context of `idn:nesr:delete`.
		         * @summary Delete Non-Employee Source
		         * @param {string} sourceId Source Id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteNonEmployeeSource: function (sourceId, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'sourceId' is not null or undefined
		                            (0, common_1.assertParamExists)('deleteNonEmployeeSource', 'sourceId', sourceId);
		                            localVarPath = "/non-employee-sources/{sourceId}"
		                                .replace("{".concat("sourceId", "}"), encodeURIComponent(String(sourceId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'DELETE' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This end-point deletes all custom schema attributes for a non-employee source. Requires role context of `idn:nesr:delete`
		         * @summary Delete all custom schema attributes for Non-Employee Source
		         * @param {string} sourceId The Source id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteNonEmployeeSourceSchemaAttributes: function (sourceId, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'sourceId' is not null or undefined
		                            (0, common_1.assertParamExists)('deleteNonEmployeeSourceSchemaAttributes', 'sourceId', sourceId);
		                            localVarPath = "/non-employee-sources/{sourceId}/schema-attributes"
		                                .replace("{".concat("sourceId", "}"), encodeURIComponent(String(sourceId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'DELETE' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This requests a CSV download for all non-employees from a provided source. Requires role context of `idn:nesr:read`
		         * @summary Exports Non-Employee Records to CSV
		         * @param {string} id Source Id (UUID)
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        exportNonEmployeeRecords: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('exportNonEmployeeRecords', 'id', id);
		                            localVarPath = "/non-employee-sources/{id}/non-employees/download"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This requests a download for the Source Schema Template for a provided source. Requires role context of `idn:nesr:read`
		         * @summary Exports Source Schema Template
		         * @param {string} id Source Id (UUID)
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        exportNonEmployeeSourceSchemaTemplate: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('exportNonEmployeeSourceSchemaTemplate', 'id', id);
		                            localVarPath = "/non-employee-sources/{id}/schema-attributes-template/download"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Gets a non-employee approval item detail. There are two contextual uses for this endpoint:   1. The user has the role context of `idn:nesr:read`, in which case they can get any approval.   2. The user owns the requested approval.
		         * @summary Get a non-employee approval item detail
		         * @param {string} id Non-Employee approval item id (UUID)
		         * @param {boolean} [includeDetail] The object nonEmployeeRequest will not be included detail when set to false. *Default value is true*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getNonEmployeeApproval: function (id, includeDetail, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getNonEmployeeApproval', 'id', id);
		                            localVarPath = "/non-employee-approvals/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (includeDetail !== undefined) {
		                                localVarQueryParameter['include-detail'] = includeDetail;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This request will retrieve a summary of non-employee approval requests. There are two contextual uses for the `requested-for` path parameter:   1. The user has the role context of `idn:nesr:read`, in which case he or she may request a summary of all non-employee approval requests assigned to a particular approver by passing in that approver\'s id.   2. The current user is an approver, in which case \"me\" should be provided as the `requested-for` value. This will provide the approver with a summary of the approval items assigned to him or her.
		         * @summary Get Summary of Non-Employee Approval Requests
		         * @param {string} requestedFor The identity (UUID) of the approver for whom for whom the summary is being retrieved. Use \&quot;me\&quot; instead to indicate the current user.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getNonEmployeeApprovalSummary: function (requestedFor, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'requestedFor' is not null or undefined
		                            (0, common_1.assertParamExists)('getNonEmployeeApprovalSummary', 'requestedFor', requestedFor);
		                            localVarPath = "/non-employee-approvals/summary/{requested-for}"
		                                .replace("{".concat("requested-for", "}"), encodeURIComponent(String(requestedFor)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * The nonEmployeeBulkUploadStatus API returns the status of the newest bulk upload job for the specified source. Requires role context of `idn:nesr:read`
		         * @summary Obtain the status of bulk upload on the source
		         * @param {string} id Source ID (UUID)
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getNonEmployeeBulkUploadStatus: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getNonEmployeeBulkUploadStatus', 'id', id);
		                            localVarPath = "/non-employee-sources/{id}/non-employee-bulk-upload/status"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets a non-employee record. Requires role context of `idn:nesr:read`
		         * @summary Get a Non-Employee Record
		         * @param {string} id Non-Employee record id (UUID)
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getNonEmployeeRecord: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getNonEmployeeRecord', 'id', id);
		                            localVarPath = "/non-employee-records/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets a non-employee request. There are two contextual uses for this endpoint:   1. The user has the role context of `idn:nesr:read`, in this case the user can get the non-employee request for any user.   2. The user must be the owner of the non-employee request.
		         * @summary Get a Non-Employee Request
		         * @param {string} id Non-Employee request id (UUID)
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getNonEmployeeRequest: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getNonEmployeeRequest', 'id', id);
		                            localVarPath = "/non-employee-requests/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This request will retrieve a summary of non-employee requests. There are two contextual uses for the `requested-for` path parameter:   1. The user has the role context of `idn:nesr:read`, in which case he or she may request a summary of all non-employee approval requests assigned to a particular account manager by passing in that manager\'s id.   2. The current user is an account manager, in which case \"me\" should be provided as the `requested-for` value. This will provide the user with a summary of the non-employee requests in the source(s) he or she manages.
		         * @summary Get Summary of Non-Employee Requests
		         * @param {string} requestedFor The identity (UUID) of the non-employee account manager for whom the summary is being retrieved. Use \&quot;me\&quot; instead to indicate the current user.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getNonEmployeeRequestSummary: function (requestedFor, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'requestedFor' is not null or undefined
		                            (0, common_1.assertParamExists)('getNonEmployeeRequestSummary', 'requestedFor', requestedFor);
		                            localVarPath = "/non-employee-requests/summary/{requested-for}"
		                                .replace("{".concat("requested-for", "}"), encodeURIComponent(String(requestedFor)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API gets a schema attribute by Id for the specified Non-Employee SourceId. Requires role context of `idn:nesr:read` or the user must be an account manager of the source.
		         * @summary Get Schema Attribute Non-Employee Source
		         * @param {string} attributeId The Schema Attribute Id (UUID)
		         * @param {string} sourceId The Source id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getNonEmployeeSchemaAttribute: function (attributeId, sourceId, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'attributeId' is not null or undefined
		                            (0, common_1.assertParamExists)('getNonEmployeeSchemaAttribute', 'attributeId', attributeId);
		                            // verify required parameter 'sourceId' is not null or undefined
		                            (0, common_1.assertParamExists)('getNonEmployeeSchemaAttribute', 'sourceId', sourceId);
		                            localVarPath = "/non-employee-sources/{sourceId}/schema-attributes/{attributeId}"
		                                .replace("{".concat("attributeId", "}"), encodeURIComponent(String(attributeId)))
		                                .replace("{".concat("sourceId", "}"), encodeURIComponent(String(sourceId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets a non-employee source. There are two contextual uses for the requested-for path parameter:    1. The user has the role context of `idn:nesr:read`, in which case he or she may request any source.   2. The current user is an account manager, in which case the user can only request sources that they own.
		         * @summary Get a Non-Employee Source
		         * @param {string} sourceId Source Id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getNonEmployeeSource: function (sourceId, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'sourceId' is not null or undefined
		                            (0, common_1.assertParamExists)('getNonEmployeeSource', 'sourceId', sourceId);
		                            localVarPath = "/non-employee-sources/{sourceId}"
		                                .replace("{".concat("sourceId", "}"), encodeURIComponent(String(sourceId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API gets the list of schema attributes for the specified Non-Employee SourceId. There are 8 mandatory attributes added to each new Non-Employee Source automatically. Additionaly, user can add up to 10 custom attributes. This interface returns all the mandatory attributes followed by any custom attributes. At most, a total of 18 attributes will be returned. Requires role context of `idn:nesr:read` or the user must be an account manager of the source.
		         * @summary List Schema Attributes Non-Employee Source
		         * @param {string} sourceId The Source id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getNonEmployeeSourceSchemaAttributes: function (sourceId, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'sourceId' is not null or undefined
		                            (0, common_1.assertParamExists)('getNonEmployeeSourceSchemaAttributes', 'sourceId', sourceId);
		                            localVarPath = "/non-employee-sources/{sourceId}/schema-attributes"
		                                .replace("{".concat("sourceId", "}"), encodeURIComponent(String(sourceId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This post will import, or update, Non-Employee records found in the CSV. Requires role context of `idn:nesr:create`
		         * @summary Imports, or Updates, Non-Employee Records
		         * @param {string} id Source Id (UUID)
		         * @param {any} data
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        importNonEmployeeRecordsInBulk: function (id, data, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, localVarFormParams, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('importNonEmployeeRecordsInBulk', 'id', id);
		                            // verify required parameter 'data' is not null or undefined
		                            (0, common_1.assertParamExists)('importNonEmployeeRecordsInBulk', 'data', data);
		                            localVarPath = "/non-employee-sources/{id}/non-employee-bulk-upload"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            localVarFormParams = new ((configuration && configuration.formDataCtor) || FormData)();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (data !== undefined) {
		                                localVarFormParams.append('data', data);
		                            }
		                            localVarHeaderParameter['Content-Type'] = 'multipart/form-data';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = localVarFormParams;
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets a list of non-employee approval requests. There are two contextual uses for this endpoint:   1. The user has the role context of `idn:nesr:read`, in which case they can list the approvals for any approver.   2. The user owns the requested approval.
		         * @summary Get List of Non-Employee Approval Requests
		         * @param {string} [requestedFor] The identity for whom the request was made. *me* indicates the current user.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **approvalStatus**: *eq*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **created, modified**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listNonEmployeeApprovals: function (requestedFor, limit, offset, count, filters, sorters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/non-employee-approvals";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (requestedFor !== undefined) {
		                                localVarQueryParameter['requested-for'] = requestedFor;
		                            }
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets a list of non-employee records. There are two contextual uses for this endpoint:   1. The user has the role context of `idn:nesr:read`, in which case they can get a list of all of the non-employees.   2. The user is an account manager, in which case they can get a list of the non-employees that they manage.
		         * @summary List Non-Employee Records
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **id, accountName, sourceId, manager, firstName, lastName, email, phone, startDate, endDate, created, modified**
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **sourceId**: *eq*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listNonEmployeeRecords: function (limit, offset, count, sorters, filters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/non-employee-records";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets a list of non-employee requests. There are two contextual uses for the `requested-for` path parameter:   1. The user has the role context of `idn:nesr:read`, in which case he or she may request a list non-employee requests assigned to a particular account manager by passing in that manager\'s id.   2. The current user is an account manager, in which case \"me\" should be provided as the `requested-for` value. This will provide the user with a list of the non-employee requests in the source(s) he or she manages.
		         * @summary List Non-Employee Requests
		         * @param {string} requestedFor The identity for whom the request was made. *me* indicates the current user.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **created, approvalStatus, firstName, lastName, email, phone, accountName, startDate, endDate**
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **sourceId**: *eq*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listNonEmployeeRequests: function (requestedFor, limit, offset, count, sorters, filters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'requestedFor' is not null or undefined
		                            (0, common_1.assertParamExists)('listNonEmployeeRequests', 'requestedFor', requestedFor);
		                            localVarPath = "/non-employee-requests";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (requestedFor !== undefined) {
		                                localVarQueryParameter['requested-for'] = requestedFor;
		                            }
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets a list of non-employee sources. There are two contextual uses for the requested-for path parameter:    1. The user has the role context of `idn:nesr:read`, in which case he or she may request a list sources assigned to a particular account manager by passing in that manager\'s id.   2. The current user is an account manager, in which case \"me\" should be provided as the `requested-for` value. This will provide the user with a list of the sources that he or she owns.
		         * @summary List Non-Employee Sources
		         * @param {string} requestedFor The identity for whom the request was made. *me* indicates the current user.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [nonEmployeeCount] The flag to determine whether return a non-employee count associate with source.
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name, created, sourceId**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listNonEmployeeSources: function (requestedFor, limit, offset, count, nonEmployeeCount, sorters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'requestedFor' is not null or undefined
		                            (0, common_1.assertParamExists)('listNonEmployeeSources', 'requestedFor', requestedFor);
		                            localVarPath = "/non-employee-sources";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (requestedFor !== undefined) {
		                                localVarQueryParameter['requested-for'] = requestedFor;
		                            }
		                            if (nonEmployeeCount !== undefined) {
		                                localVarQueryParameter['non-employee-count'] = nonEmployeeCount;
		                            }
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This request will patch a non-employee record. There are two contextual uses for this endpoint:   1. The user has the role context of `idn:nesr:update`, in which case they update all available fields.   2. The user is owner of the source, in this case they can only update the end date.
		         * @summary Patch Non-Employee Record
		         * @param {string} id Non-employee record id (UUID)
		         * @param {Array<JsonPatchOperation>} jsonPatchOperation A list of non-employee update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard. Attributes are restricted by user type. Owner of source can update end date. Organization admins can update all available fields.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchNonEmployeeRecord: function (id, jsonPatchOperation, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('patchNonEmployeeRecord', 'id', id);
		                            // verify required parameter 'jsonPatchOperation' is not null or undefined
		                            (0, common_1.assertParamExists)('patchNonEmployeeRecord', 'jsonPatchOperation', jsonPatchOperation);
		                            localVarPath = "/non-employee-records/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PATCH' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json-patch+json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(jsonPatchOperation, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This end-point patches a specific schema attribute for a non-employee SourceId. Requires role context of `idn:nesr:update`
		         * @summary Patch a Schema Attribute for Non-Employee Source
		         * @param {string} attributeId The Schema Attribute Id (UUID)
		         * @param {string} sourceId The Source id
		         * @param {Array<JsonPatchOperation>} jsonPatchOperation A list of schema attribute update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard. The following properties are allowed for update \&#39;:\&#39; \&#39;label\&#39;, \&#39;helpText\&#39;, \&#39;placeholder\&#39;, \&#39;required\&#39;.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchNonEmployeeSchemaAttribute: function (attributeId, sourceId, jsonPatchOperation, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'attributeId' is not null or undefined
		                            (0, common_1.assertParamExists)('patchNonEmployeeSchemaAttribute', 'attributeId', attributeId);
		                            // verify required parameter 'sourceId' is not null or undefined
		                            (0, common_1.assertParamExists)('patchNonEmployeeSchemaAttribute', 'sourceId', sourceId);
		                            // verify required parameter 'jsonPatchOperation' is not null or undefined
		                            (0, common_1.assertParamExists)('patchNonEmployeeSchemaAttribute', 'jsonPatchOperation', jsonPatchOperation);
		                            localVarPath = "/non-employee-sources/{sourceId}/schema-attributes/{attributeId}"
		                                .replace("{".concat("attributeId", "}"), encodeURIComponent(String(attributeId)))
		                                .replace("{".concat("sourceId", "}"), encodeURIComponent(String(sourceId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PATCH' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json-patch+json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(jsonPatchOperation, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * patch a non-employee source. (partial update) <br/> Patchable field: **name, description, approvers, accountManagers** Requires role context of `idn:nesr:update`.
		         * @summary Patch a Non-Employee Source
		         * @param {string} sourceId Source Id
		         * @param {Array<JsonPatchOperation>} jsonPatchOperation A list of non-employee source update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchNonEmployeeSource: function (sourceId, jsonPatchOperation, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'sourceId' is not null or undefined
		                            (0, common_1.assertParamExists)('patchNonEmployeeSource', 'sourceId', sourceId);
		                            // verify required parameter 'jsonPatchOperation' is not null or undefined
		                            (0, common_1.assertParamExists)('patchNonEmployeeSource', 'jsonPatchOperation', jsonPatchOperation);
		                            localVarPath = "/non-employee-sources/{sourceId}"
		                                .replace("{".concat("sourceId", "}"), encodeURIComponent(String(sourceId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PATCH' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json-patch+json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(jsonPatchOperation, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This endpoint will reject an approval item request and notify user. The current user must be the requested approver.
		         * @summary Reject a Non-Employee Request
		         * @param {string} id Non-Employee approval item id (UUID)
		         * @param {NonEmployeeRejectApprovalDecision} nonEmployeeRejectApprovalDecision
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        rejectNonEmployeeRequest: function (id, nonEmployeeRejectApprovalDecision, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('rejectNonEmployeeRequest', 'id', id);
		                            // verify required parameter 'nonEmployeeRejectApprovalDecision' is not null or undefined
		                            (0, common_1.assertParamExists)('rejectNonEmployeeRequest', 'nonEmployeeRejectApprovalDecision', nonEmployeeRejectApprovalDecision);
		                            localVarPath = "/non-employee-approvals/{id}/reject"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(nonEmployeeRejectApprovalDecision, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This request will update a non-employee record. There are two contextual uses for this endpoint:   1. The user has the role context of `idn:nesr:update`, in which case they update all available fields.   2. The user is owner of the source, in this case they can only update the end date.
		         * @summary Update Non-Employee Record
		         * @param {string} id Non-employee record id (UUID)
		         * @param {NonEmployeeRequestBody} nonEmployeeRequestBody Non-employee record creation request body. Attributes are restricted by user type. Owner of source can update end date. Organization admins can update all available fields.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateNonEmployeeRecord: function (id, nonEmployeeRequestBody, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('updateNonEmployeeRecord', 'id', id);
		                            // verify required parameter 'nonEmployeeRequestBody' is not null or undefined
		                            (0, common_1.assertParamExists)('updateNonEmployeeRecord', 'nonEmployeeRequestBody', nonEmployeeRequestBody);
		                            localVarPath = "/non-employee-records/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PUT' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(nonEmployeeRequestBody, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.NonEmployeeLifecycleManagementApiAxiosParamCreator = NonEmployeeLifecycleManagementApiAxiosParamCreator;
		/**
		 * NonEmployeeLifecycleManagementApi - functional programming interface
		 * @export
		 */
		var NonEmployeeLifecycleManagementApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.NonEmployeeLifecycleManagementApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * Approves a non-employee approval request and notifies the next approver. The current user must be the requested approver.
		         * @summary Approve a Non-Employee Request
		         * @param {string} id Non-Employee approval item id (UUID)
		         * @param {NonEmployeeApprovalDecision} nonEmployeeApprovalDecision
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        approveNonEmployeeRequest: function (id, nonEmployeeApprovalDecision, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.approveNonEmployeeRequest(id, nonEmployeeApprovalDecision, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This request will create a non-employee record. Requires role context of `idn:nesr:create`
		         * @summary Create Non-Employee Record
		         * @param {NonEmployeeRequestBody} nonEmployeeRequestBody Non-Employee record creation request body.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createNonEmployeeRecord: function (nonEmployeeRequestBody, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.createNonEmployeeRecord(nonEmployeeRequestBody, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This request will create a non-employee request and notify the approver. Requires role context of `idn:nesr:create` or the user must own the source.
		         * @summary Create Non-Employee Request
		         * @param {NonEmployeeRequestBody} nonEmployeeRequestBody Non-Employee creation request body
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createNonEmployeeRequest: function (nonEmployeeRequestBody, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.createNonEmployeeRequest(nonEmployeeRequestBody, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This request will create a non-employee source. Requires role context of `idn:nesr:create`
		         * @summary Create Non-Employee Source
		         * @param {NonEmployeeSourceRequestBody} nonEmployeeSourceRequestBody Non-Employee source creation request body.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createNonEmployeeSource: function (nonEmployeeSourceRequestBody, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.createNonEmployeeSource(nonEmployeeSourceRequestBody, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API creates a new schema attribute for Non-Employee Source. The schema technical name must be unique in the source. Attempts to create a schema attribute with an existing name will result in a \"400.1.409 Reference conflict\" response. At most, 10 custom attributes can be created per schema. Attempts to create more than 10 will result in a \"400.1.4 Limit violation\" response. Requires role context of `idn:nesr:create`
		         * @summary Create a new Schema Attribute for Non-Employee Source
		         * @param {string} sourceId The Source id
		         * @param {NonEmployeeSchemaAttributeBody} nonEmployeeSchemaAttributeBody
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createNonEmployeeSourceSchemaAttributes: function (sourceId, nonEmployeeSchemaAttributeBody, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.createNonEmployeeSourceSchemaAttributes(sourceId, nonEmployeeSchemaAttributeBody, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This request will delete a non-employee record. Requires role context of `idn:nesr:delete`
		         * @summary Delete Non-Employee Record
		         * @param {string} id Non-Employee record id (UUID)
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteNonEmployeeRecord: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.deleteNonEmployeeRecord(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This request will delete multiple non-employee records based on the non-employee ids provided. Requires role context of `idn:nesr:delete`
		         * @summary Delete Multiple Non-Employee Records
		         * @param {DeleteNonEmployeeRecordsInBulkRequest} deleteNonEmployeeRecordsInBulkRequest Non-Employee bulk delete request body.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteNonEmployeeRecordsInBulk: function (deleteNonEmployeeRecordsInBulkRequest, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.deleteNonEmployeeRecordsInBulk(deleteNonEmployeeRecordsInBulkRequest, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This request will delete a non-employee request.  Requires role context of `idn:nesr:delete`
		         * @summary Delete Non-Employee Request
		         * @param {string} id Non-Employee request id in the UUID format
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteNonEmployeeRequest: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.deleteNonEmployeeRequest(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This end-point deletes a specific schema attribute for a non-employee source. Requires role context of `idn:nesr:delete`
		         * @summary Delete a Schema Attribute for Non-Employee Source
		         * @param {string} attributeId The Schema Attribute Id (UUID)
		         * @param {string} sourceId The Source id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteNonEmployeeSchemaAttribute: function (attributeId, sourceId, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.deleteNonEmployeeSchemaAttribute(attributeId, sourceId, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This request will delete a non-employee source. Requires role context of `idn:nesr:delete`.
		         * @summary Delete Non-Employee Source
		         * @param {string} sourceId Source Id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteNonEmployeeSource: function (sourceId, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.deleteNonEmployeeSource(sourceId, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This end-point deletes all custom schema attributes for a non-employee source. Requires role context of `idn:nesr:delete`
		         * @summary Delete all custom schema attributes for Non-Employee Source
		         * @param {string} sourceId The Source id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteNonEmployeeSourceSchemaAttributes: function (sourceId, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.deleteNonEmployeeSourceSchemaAttributes(sourceId, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This requests a CSV download for all non-employees from a provided source. Requires role context of `idn:nesr:read`
		         * @summary Exports Non-Employee Records to CSV
		         * @param {string} id Source Id (UUID)
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        exportNonEmployeeRecords: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.exportNonEmployeeRecords(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This requests a download for the Source Schema Template for a provided source. Requires role context of `idn:nesr:read`
		         * @summary Exports Source Schema Template
		         * @param {string} id Source Id (UUID)
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        exportNonEmployeeSourceSchemaTemplate: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.exportNonEmployeeSourceSchemaTemplate(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Gets a non-employee approval item detail. There are two contextual uses for this endpoint:   1. The user has the role context of `idn:nesr:read`, in which case they can get any approval.   2. The user owns the requested approval.
		         * @summary Get a non-employee approval item detail
		         * @param {string} id Non-Employee approval item id (UUID)
		         * @param {boolean} [includeDetail] The object nonEmployeeRequest will not be included detail when set to false. *Default value is true*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getNonEmployeeApproval: function (id, includeDetail, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getNonEmployeeApproval(id, includeDetail, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This request will retrieve a summary of non-employee approval requests. There are two contextual uses for the `requested-for` path parameter:   1. The user has the role context of `idn:nesr:read`, in which case he or she may request a summary of all non-employee approval requests assigned to a particular approver by passing in that approver\'s id.   2. The current user is an approver, in which case \"me\" should be provided as the `requested-for` value. This will provide the approver with a summary of the approval items assigned to him or her.
		         * @summary Get Summary of Non-Employee Approval Requests
		         * @param {string} requestedFor The identity (UUID) of the approver for whom for whom the summary is being retrieved. Use \&quot;me\&quot; instead to indicate the current user.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getNonEmployeeApprovalSummary: function (requestedFor, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getNonEmployeeApprovalSummary(requestedFor, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * The nonEmployeeBulkUploadStatus API returns the status of the newest bulk upload job for the specified source. Requires role context of `idn:nesr:read`
		         * @summary Obtain the status of bulk upload on the source
		         * @param {string} id Source ID (UUID)
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getNonEmployeeBulkUploadStatus: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getNonEmployeeBulkUploadStatus(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets a non-employee record. Requires role context of `idn:nesr:read`
		         * @summary Get a Non-Employee Record
		         * @param {string} id Non-Employee record id (UUID)
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getNonEmployeeRecord: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getNonEmployeeRecord(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets a non-employee request. There are two contextual uses for this endpoint:   1. The user has the role context of `idn:nesr:read`, in this case the user can get the non-employee request for any user.   2. The user must be the owner of the non-employee request.
		         * @summary Get a Non-Employee Request
		         * @param {string} id Non-Employee request id (UUID)
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getNonEmployeeRequest: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getNonEmployeeRequest(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This request will retrieve a summary of non-employee requests. There are two contextual uses for the `requested-for` path parameter:   1. The user has the role context of `idn:nesr:read`, in which case he or she may request a summary of all non-employee approval requests assigned to a particular account manager by passing in that manager\'s id.   2. The current user is an account manager, in which case \"me\" should be provided as the `requested-for` value. This will provide the user with a summary of the non-employee requests in the source(s) he or she manages.
		         * @summary Get Summary of Non-Employee Requests
		         * @param {string} requestedFor The identity (UUID) of the non-employee account manager for whom the summary is being retrieved. Use \&quot;me\&quot; instead to indicate the current user.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getNonEmployeeRequestSummary: function (requestedFor, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getNonEmployeeRequestSummary(requestedFor, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API gets a schema attribute by Id for the specified Non-Employee SourceId. Requires role context of `idn:nesr:read` or the user must be an account manager of the source.
		         * @summary Get Schema Attribute Non-Employee Source
		         * @param {string} attributeId The Schema Attribute Id (UUID)
		         * @param {string} sourceId The Source id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getNonEmployeeSchemaAttribute: function (attributeId, sourceId, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getNonEmployeeSchemaAttribute(attributeId, sourceId, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets a non-employee source. There are two contextual uses for the requested-for path parameter:    1. The user has the role context of `idn:nesr:read`, in which case he or she may request any source.   2. The current user is an account manager, in which case the user can only request sources that they own.
		         * @summary Get a Non-Employee Source
		         * @param {string} sourceId Source Id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getNonEmployeeSource: function (sourceId, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getNonEmployeeSource(sourceId, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API gets the list of schema attributes for the specified Non-Employee SourceId. There are 8 mandatory attributes added to each new Non-Employee Source automatically. Additionaly, user can add up to 10 custom attributes. This interface returns all the mandatory attributes followed by any custom attributes. At most, a total of 18 attributes will be returned. Requires role context of `idn:nesr:read` or the user must be an account manager of the source.
		         * @summary List Schema Attributes Non-Employee Source
		         * @param {string} sourceId The Source id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getNonEmployeeSourceSchemaAttributes: function (sourceId, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getNonEmployeeSourceSchemaAttributes(sourceId, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This post will import, or update, Non-Employee records found in the CSV. Requires role context of `idn:nesr:create`
		         * @summary Imports, or Updates, Non-Employee Records
		         * @param {string} id Source Id (UUID)
		         * @param {any} data
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        importNonEmployeeRecordsInBulk: function (id, data, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.importNonEmployeeRecordsInBulk(id, data, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets a list of non-employee approval requests. There are two contextual uses for this endpoint:   1. The user has the role context of `idn:nesr:read`, in which case they can list the approvals for any approver.   2. The user owns the requested approval.
		         * @summary Get List of Non-Employee Approval Requests
		         * @param {string} [requestedFor] The identity for whom the request was made. *me* indicates the current user.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **approvalStatus**: *eq*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **created, modified**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listNonEmployeeApprovals: function (requestedFor, limit, offset, count, filters, sorters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listNonEmployeeApprovals(requestedFor, limit, offset, count, filters, sorters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets a list of non-employee records. There are two contextual uses for this endpoint:   1. The user has the role context of `idn:nesr:read`, in which case they can get a list of all of the non-employees.   2. The user is an account manager, in which case they can get a list of the non-employees that they manage.
		         * @summary List Non-Employee Records
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **id, accountName, sourceId, manager, firstName, lastName, email, phone, startDate, endDate, created, modified**
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **sourceId**: *eq*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listNonEmployeeRecords: function (limit, offset, count, sorters, filters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listNonEmployeeRecords(limit, offset, count, sorters, filters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets a list of non-employee requests. There are two contextual uses for the `requested-for` path parameter:   1. The user has the role context of `idn:nesr:read`, in which case he or she may request a list non-employee requests assigned to a particular account manager by passing in that manager\'s id.   2. The current user is an account manager, in which case \"me\" should be provided as the `requested-for` value. This will provide the user with a list of the non-employee requests in the source(s) he or she manages.
		         * @summary List Non-Employee Requests
		         * @param {string} requestedFor The identity for whom the request was made. *me* indicates the current user.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **created, approvalStatus, firstName, lastName, email, phone, accountName, startDate, endDate**
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **sourceId**: *eq*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listNonEmployeeRequests: function (requestedFor, limit, offset, count, sorters, filters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listNonEmployeeRequests(requestedFor, limit, offset, count, sorters, filters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets a list of non-employee sources. There are two contextual uses for the requested-for path parameter:    1. The user has the role context of `idn:nesr:read`, in which case he or she may request a list sources assigned to a particular account manager by passing in that manager\'s id.   2. The current user is an account manager, in which case \"me\" should be provided as the `requested-for` value. This will provide the user with a list of the sources that he or she owns.
		         * @summary List Non-Employee Sources
		         * @param {string} requestedFor The identity for whom the request was made. *me* indicates the current user.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [nonEmployeeCount] The flag to determine whether return a non-employee count associate with source.
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name, created, sourceId**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listNonEmployeeSources: function (requestedFor, limit, offset, count, nonEmployeeCount, sorters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listNonEmployeeSources(requestedFor, limit, offset, count, nonEmployeeCount, sorters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This request will patch a non-employee record. There are two contextual uses for this endpoint:   1. The user has the role context of `idn:nesr:update`, in which case they update all available fields.   2. The user is owner of the source, in this case they can only update the end date.
		         * @summary Patch Non-Employee Record
		         * @param {string} id Non-employee record id (UUID)
		         * @param {Array<JsonPatchOperation>} jsonPatchOperation A list of non-employee update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard. Attributes are restricted by user type. Owner of source can update end date. Organization admins can update all available fields.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchNonEmployeeRecord: function (id, jsonPatchOperation, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.patchNonEmployeeRecord(id, jsonPatchOperation, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This end-point patches a specific schema attribute for a non-employee SourceId. Requires role context of `idn:nesr:update`
		         * @summary Patch a Schema Attribute for Non-Employee Source
		         * @param {string} attributeId The Schema Attribute Id (UUID)
		         * @param {string} sourceId The Source id
		         * @param {Array<JsonPatchOperation>} jsonPatchOperation A list of schema attribute update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard. The following properties are allowed for update \&#39;:\&#39; \&#39;label\&#39;, \&#39;helpText\&#39;, \&#39;placeholder\&#39;, \&#39;required\&#39;.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchNonEmployeeSchemaAttribute: function (attributeId, sourceId, jsonPatchOperation, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.patchNonEmployeeSchemaAttribute(attributeId, sourceId, jsonPatchOperation, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * patch a non-employee source. (partial update) <br/> Patchable field: **name, description, approvers, accountManagers** Requires role context of `idn:nesr:update`.
		         * @summary Patch a Non-Employee Source
		         * @param {string} sourceId Source Id
		         * @param {Array<JsonPatchOperation>} jsonPatchOperation A list of non-employee source update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchNonEmployeeSource: function (sourceId, jsonPatchOperation, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.patchNonEmployeeSource(sourceId, jsonPatchOperation, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This endpoint will reject an approval item request and notify user. The current user must be the requested approver.
		         * @summary Reject a Non-Employee Request
		         * @param {string} id Non-Employee approval item id (UUID)
		         * @param {NonEmployeeRejectApprovalDecision} nonEmployeeRejectApprovalDecision
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        rejectNonEmployeeRequest: function (id, nonEmployeeRejectApprovalDecision, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.rejectNonEmployeeRequest(id, nonEmployeeRejectApprovalDecision, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This request will update a non-employee record. There are two contextual uses for this endpoint:   1. The user has the role context of `idn:nesr:update`, in which case they update all available fields.   2. The user is owner of the source, in this case they can only update the end date.
		         * @summary Update Non-Employee Record
		         * @param {string} id Non-employee record id (UUID)
		         * @param {NonEmployeeRequestBody} nonEmployeeRequestBody Non-employee record creation request body. Attributes are restricted by user type. Owner of source can update end date. Organization admins can update all available fields.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateNonEmployeeRecord: function (id, nonEmployeeRequestBody, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.updateNonEmployeeRecord(id, nonEmployeeRequestBody, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.NonEmployeeLifecycleManagementApiFp = NonEmployeeLifecycleManagementApiFp;
		/**
		 * NonEmployeeLifecycleManagementApi - factory interface
		 * @export
		 */
		var NonEmployeeLifecycleManagementApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.NonEmployeeLifecycleManagementApiFp)(configuration);
		    return {
		        /**
		         * Approves a non-employee approval request and notifies the next approver. The current user must be the requested approver.
		         * @summary Approve a Non-Employee Request
		         * @param {string} id Non-Employee approval item id (UUID)
		         * @param {NonEmployeeApprovalDecision} nonEmployeeApprovalDecision
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        approveNonEmployeeRequest: function (id, nonEmployeeApprovalDecision, axiosOptions) {
		            return localVarFp.approveNonEmployeeRequest(id, nonEmployeeApprovalDecision, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This request will create a non-employee record. Requires role context of `idn:nesr:create`
		         * @summary Create Non-Employee Record
		         * @param {NonEmployeeRequestBody} nonEmployeeRequestBody Non-Employee record creation request body.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createNonEmployeeRecord: function (nonEmployeeRequestBody, axiosOptions) {
		            return localVarFp.createNonEmployeeRecord(nonEmployeeRequestBody, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This request will create a non-employee request and notify the approver. Requires role context of `idn:nesr:create` or the user must own the source.
		         * @summary Create Non-Employee Request
		         * @param {NonEmployeeRequestBody} nonEmployeeRequestBody Non-Employee creation request body
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createNonEmployeeRequest: function (nonEmployeeRequestBody, axiosOptions) {
		            return localVarFp.createNonEmployeeRequest(nonEmployeeRequestBody, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This request will create a non-employee source. Requires role context of `idn:nesr:create`
		         * @summary Create Non-Employee Source
		         * @param {NonEmployeeSourceRequestBody} nonEmployeeSourceRequestBody Non-Employee source creation request body.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createNonEmployeeSource: function (nonEmployeeSourceRequestBody, axiosOptions) {
		            return localVarFp.createNonEmployeeSource(nonEmployeeSourceRequestBody, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API creates a new schema attribute for Non-Employee Source. The schema technical name must be unique in the source. Attempts to create a schema attribute with an existing name will result in a \"400.1.409 Reference conflict\" response. At most, 10 custom attributes can be created per schema. Attempts to create more than 10 will result in a \"400.1.4 Limit violation\" response. Requires role context of `idn:nesr:create`
		         * @summary Create a new Schema Attribute for Non-Employee Source
		         * @param {string} sourceId The Source id
		         * @param {NonEmployeeSchemaAttributeBody} nonEmployeeSchemaAttributeBody
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createNonEmployeeSourceSchemaAttributes: function (sourceId, nonEmployeeSchemaAttributeBody, axiosOptions) {
		            return localVarFp.createNonEmployeeSourceSchemaAttributes(sourceId, nonEmployeeSchemaAttributeBody, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This request will delete a non-employee record. Requires role context of `idn:nesr:delete`
		         * @summary Delete Non-Employee Record
		         * @param {string} id Non-Employee record id (UUID)
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteNonEmployeeRecord: function (id, axiosOptions) {
		            return localVarFp.deleteNonEmployeeRecord(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This request will delete multiple non-employee records based on the non-employee ids provided. Requires role context of `idn:nesr:delete`
		         * @summary Delete Multiple Non-Employee Records
		         * @param {DeleteNonEmployeeRecordsInBulkRequest} deleteNonEmployeeRecordsInBulkRequest Non-Employee bulk delete request body.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteNonEmployeeRecordsInBulk: function (deleteNonEmployeeRecordsInBulkRequest, axiosOptions) {
		            return localVarFp.deleteNonEmployeeRecordsInBulk(deleteNonEmployeeRecordsInBulkRequest, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This request will delete a non-employee request.  Requires role context of `idn:nesr:delete`
		         * @summary Delete Non-Employee Request
		         * @param {string} id Non-Employee request id in the UUID format
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteNonEmployeeRequest: function (id, axiosOptions) {
		            return localVarFp.deleteNonEmployeeRequest(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This end-point deletes a specific schema attribute for a non-employee source. Requires role context of `idn:nesr:delete`
		         * @summary Delete a Schema Attribute for Non-Employee Source
		         * @param {string} attributeId The Schema Attribute Id (UUID)
		         * @param {string} sourceId The Source id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteNonEmployeeSchemaAttribute: function (attributeId, sourceId, axiosOptions) {
		            return localVarFp.deleteNonEmployeeSchemaAttribute(attributeId, sourceId, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This request will delete a non-employee source. Requires role context of `idn:nesr:delete`.
		         * @summary Delete Non-Employee Source
		         * @param {string} sourceId Source Id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteNonEmployeeSource: function (sourceId, axiosOptions) {
		            return localVarFp.deleteNonEmployeeSource(sourceId, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This end-point deletes all custom schema attributes for a non-employee source. Requires role context of `idn:nesr:delete`
		         * @summary Delete all custom schema attributes for Non-Employee Source
		         * @param {string} sourceId The Source id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteNonEmployeeSourceSchemaAttributes: function (sourceId, axiosOptions) {
		            return localVarFp.deleteNonEmployeeSourceSchemaAttributes(sourceId, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This requests a CSV download for all non-employees from a provided source. Requires role context of `idn:nesr:read`
		         * @summary Exports Non-Employee Records to CSV
		         * @param {string} id Source Id (UUID)
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        exportNonEmployeeRecords: function (id, axiosOptions) {
		            return localVarFp.exportNonEmployeeRecords(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This requests a download for the Source Schema Template for a provided source. Requires role context of `idn:nesr:read`
		         * @summary Exports Source Schema Template
		         * @param {string} id Source Id (UUID)
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        exportNonEmployeeSourceSchemaTemplate: function (id, axiosOptions) {
		            return localVarFp.exportNonEmployeeSourceSchemaTemplate(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Gets a non-employee approval item detail. There are two contextual uses for this endpoint:   1. The user has the role context of `idn:nesr:read`, in which case they can get any approval.   2. The user owns the requested approval.
		         * @summary Get a non-employee approval item detail
		         * @param {string} id Non-Employee approval item id (UUID)
		         * @param {boolean} [includeDetail] The object nonEmployeeRequest will not be included detail when set to false. *Default value is true*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getNonEmployeeApproval: function (id, includeDetail, axiosOptions) {
		            return localVarFp.getNonEmployeeApproval(id, includeDetail, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This request will retrieve a summary of non-employee approval requests. There are two contextual uses for the `requested-for` path parameter:   1. The user has the role context of `idn:nesr:read`, in which case he or she may request a summary of all non-employee approval requests assigned to a particular approver by passing in that approver\'s id.   2. The current user is an approver, in which case \"me\" should be provided as the `requested-for` value. This will provide the approver with a summary of the approval items assigned to him or her.
		         * @summary Get Summary of Non-Employee Approval Requests
		         * @param {string} requestedFor The identity (UUID) of the approver for whom for whom the summary is being retrieved. Use \&quot;me\&quot; instead to indicate the current user.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getNonEmployeeApprovalSummary: function (requestedFor, axiosOptions) {
		            return localVarFp.getNonEmployeeApprovalSummary(requestedFor, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * The nonEmployeeBulkUploadStatus API returns the status of the newest bulk upload job for the specified source. Requires role context of `idn:nesr:read`
		         * @summary Obtain the status of bulk upload on the source
		         * @param {string} id Source ID (UUID)
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getNonEmployeeBulkUploadStatus: function (id, axiosOptions) {
		            return localVarFp.getNonEmployeeBulkUploadStatus(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This gets a non-employee record. Requires role context of `idn:nesr:read`
		         * @summary Get a Non-Employee Record
		         * @param {string} id Non-Employee record id (UUID)
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getNonEmployeeRecord: function (id, axiosOptions) {
		            return localVarFp.getNonEmployeeRecord(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This gets a non-employee request. There are two contextual uses for this endpoint:   1. The user has the role context of `idn:nesr:read`, in this case the user can get the non-employee request for any user.   2. The user must be the owner of the non-employee request.
		         * @summary Get a Non-Employee Request
		         * @param {string} id Non-Employee request id (UUID)
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getNonEmployeeRequest: function (id, axiosOptions) {
		            return localVarFp.getNonEmployeeRequest(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This request will retrieve a summary of non-employee requests. There are two contextual uses for the `requested-for` path parameter:   1. The user has the role context of `idn:nesr:read`, in which case he or she may request a summary of all non-employee approval requests assigned to a particular account manager by passing in that manager\'s id.   2. The current user is an account manager, in which case \"me\" should be provided as the `requested-for` value. This will provide the user with a summary of the non-employee requests in the source(s) he or she manages.
		         * @summary Get Summary of Non-Employee Requests
		         * @param {string} requestedFor The identity (UUID) of the non-employee account manager for whom the summary is being retrieved. Use \&quot;me\&quot; instead to indicate the current user.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getNonEmployeeRequestSummary: function (requestedFor, axiosOptions) {
		            return localVarFp.getNonEmployeeRequestSummary(requestedFor, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API gets a schema attribute by Id for the specified Non-Employee SourceId. Requires role context of `idn:nesr:read` or the user must be an account manager of the source.
		         * @summary Get Schema Attribute Non-Employee Source
		         * @param {string} attributeId The Schema Attribute Id (UUID)
		         * @param {string} sourceId The Source id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getNonEmployeeSchemaAttribute: function (attributeId, sourceId, axiosOptions) {
		            return localVarFp.getNonEmployeeSchemaAttribute(attributeId, sourceId, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This gets a non-employee source. There are two contextual uses for the requested-for path parameter:    1. The user has the role context of `idn:nesr:read`, in which case he or she may request any source.   2. The current user is an account manager, in which case the user can only request sources that they own.
		         * @summary Get a Non-Employee Source
		         * @param {string} sourceId Source Id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getNonEmployeeSource: function (sourceId, axiosOptions) {
		            return localVarFp.getNonEmployeeSource(sourceId, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API gets the list of schema attributes for the specified Non-Employee SourceId. There are 8 mandatory attributes added to each new Non-Employee Source automatically. Additionaly, user can add up to 10 custom attributes. This interface returns all the mandatory attributes followed by any custom attributes. At most, a total of 18 attributes will be returned. Requires role context of `idn:nesr:read` or the user must be an account manager of the source.
		         * @summary List Schema Attributes Non-Employee Source
		         * @param {string} sourceId The Source id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getNonEmployeeSourceSchemaAttributes: function (sourceId, axiosOptions) {
		            return localVarFp.getNonEmployeeSourceSchemaAttributes(sourceId, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This post will import, or update, Non-Employee records found in the CSV. Requires role context of `idn:nesr:create`
		         * @summary Imports, or Updates, Non-Employee Records
		         * @param {string} id Source Id (UUID)
		         * @param {any} data
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        importNonEmployeeRecordsInBulk: function (id, data, axiosOptions) {
		            return localVarFp.importNonEmployeeRecordsInBulk(id, data, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This gets a list of non-employee approval requests. There are two contextual uses for this endpoint:   1. The user has the role context of `idn:nesr:read`, in which case they can list the approvals for any approver.   2. The user owns the requested approval.
		         * @summary Get List of Non-Employee Approval Requests
		         * @param {string} [requestedFor] The identity for whom the request was made. *me* indicates the current user.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **approvalStatus**: *eq*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **created, modified**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listNonEmployeeApprovals: function (requestedFor, limit, offset, count, filters, sorters, axiosOptions) {
		            return localVarFp.listNonEmployeeApprovals(requestedFor, limit, offset, count, filters, sorters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This gets a list of non-employee records. There are two contextual uses for this endpoint:   1. The user has the role context of `idn:nesr:read`, in which case they can get a list of all of the non-employees.   2. The user is an account manager, in which case they can get a list of the non-employees that they manage.
		         * @summary List Non-Employee Records
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **id, accountName, sourceId, manager, firstName, lastName, email, phone, startDate, endDate, created, modified**
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **sourceId**: *eq*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listNonEmployeeRecords: function (limit, offset, count, sorters, filters, axiosOptions) {
		            return localVarFp.listNonEmployeeRecords(limit, offset, count, sorters, filters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This gets a list of non-employee requests. There are two contextual uses for the `requested-for` path parameter:   1. The user has the role context of `idn:nesr:read`, in which case he or she may request a list non-employee requests assigned to a particular account manager by passing in that manager\'s id.   2. The current user is an account manager, in which case \"me\" should be provided as the `requested-for` value. This will provide the user with a list of the non-employee requests in the source(s) he or she manages.
		         * @summary List Non-Employee Requests
		         * @param {string} requestedFor The identity for whom the request was made. *me* indicates the current user.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **created, approvalStatus, firstName, lastName, email, phone, accountName, startDate, endDate**
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **sourceId**: *eq*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listNonEmployeeRequests: function (requestedFor, limit, offset, count, sorters, filters, axiosOptions) {
		            return localVarFp.listNonEmployeeRequests(requestedFor, limit, offset, count, sorters, filters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This gets a list of non-employee sources. There are two contextual uses for the requested-for path parameter:    1. The user has the role context of `idn:nesr:read`, in which case he or she may request a list sources assigned to a particular account manager by passing in that manager\'s id.   2. The current user is an account manager, in which case \"me\" should be provided as the `requested-for` value. This will provide the user with a list of the sources that he or she owns.
		         * @summary List Non-Employee Sources
		         * @param {string} requestedFor The identity for whom the request was made. *me* indicates the current user.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [nonEmployeeCount] The flag to determine whether return a non-employee count associate with source.
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name, created, sourceId**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listNonEmployeeSources: function (requestedFor, limit, offset, count, nonEmployeeCount, sorters, axiosOptions) {
		            return localVarFp.listNonEmployeeSources(requestedFor, limit, offset, count, nonEmployeeCount, sorters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This request will patch a non-employee record. There are two contextual uses for this endpoint:   1. The user has the role context of `idn:nesr:update`, in which case they update all available fields.   2. The user is owner of the source, in this case they can only update the end date.
		         * @summary Patch Non-Employee Record
		         * @param {string} id Non-employee record id (UUID)
		         * @param {Array<JsonPatchOperation>} jsonPatchOperation A list of non-employee update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard. Attributes are restricted by user type. Owner of source can update end date. Organization admins can update all available fields.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchNonEmployeeRecord: function (id, jsonPatchOperation, axiosOptions) {
		            return localVarFp.patchNonEmployeeRecord(id, jsonPatchOperation, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This end-point patches a specific schema attribute for a non-employee SourceId. Requires role context of `idn:nesr:update`
		         * @summary Patch a Schema Attribute for Non-Employee Source
		         * @param {string} attributeId The Schema Attribute Id (UUID)
		         * @param {string} sourceId The Source id
		         * @param {Array<JsonPatchOperation>} jsonPatchOperation A list of schema attribute update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard. The following properties are allowed for update \&#39;:\&#39; \&#39;label\&#39;, \&#39;helpText\&#39;, \&#39;placeholder\&#39;, \&#39;required\&#39;.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchNonEmployeeSchemaAttribute: function (attributeId, sourceId, jsonPatchOperation, axiosOptions) {
		            return localVarFp.patchNonEmployeeSchemaAttribute(attributeId, sourceId, jsonPatchOperation, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * patch a non-employee source. (partial update) <br/> Patchable field: **name, description, approvers, accountManagers** Requires role context of `idn:nesr:update`.
		         * @summary Patch a Non-Employee Source
		         * @param {string} sourceId Source Id
		         * @param {Array<JsonPatchOperation>} jsonPatchOperation A list of non-employee source update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchNonEmployeeSource: function (sourceId, jsonPatchOperation, axiosOptions) {
		            return localVarFp.patchNonEmployeeSource(sourceId, jsonPatchOperation, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This endpoint will reject an approval item request and notify user. The current user must be the requested approver.
		         * @summary Reject a Non-Employee Request
		         * @param {string} id Non-Employee approval item id (UUID)
		         * @param {NonEmployeeRejectApprovalDecision} nonEmployeeRejectApprovalDecision
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        rejectNonEmployeeRequest: function (id, nonEmployeeRejectApprovalDecision, axiosOptions) {
		            return localVarFp.rejectNonEmployeeRequest(id, nonEmployeeRejectApprovalDecision, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This request will update a non-employee record. There are two contextual uses for this endpoint:   1. The user has the role context of `idn:nesr:update`, in which case they update all available fields.   2. The user is owner of the source, in this case they can only update the end date.
		         * @summary Update Non-Employee Record
		         * @param {string} id Non-employee record id (UUID)
		         * @param {NonEmployeeRequestBody} nonEmployeeRequestBody Non-employee record creation request body. Attributes are restricted by user type. Owner of source can update end date. Organization admins can update all available fields.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateNonEmployeeRecord: function (id, nonEmployeeRequestBody, axiosOptions) {
		            return localVarFp.updateNonEmployeeRecord(id, nonEmployeeRequestBody, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.NonEmployeeLifecycleManagementApiFactory = NonEmployeeLifecycleManagementApiFactory;
		/**
		 * NonEmployeeLifecycleManagementApi - object-oriented interface
		 * @export
		 * @class NonEmployeeLifecycleManagementApi
		 * @extends {BaseAPI}
		 */
		var NonEmployeeLifecycleManagementApi = /** @class */ (function (_super) {
		    __extends(NonEmployeeLifecycleManagementApi, _super);
		    function NonEmployeeLifecycleManagementApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * Approves a non-employee approval request and notifies the next approver. The current user must be the requested approver.
		     * @summary Approve a Non-Employee Request
		     * @param {NonEmployeeLifecycleManagementApiApproveNonEmployeeRequestRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof NonEmployeeLifecycleManagementApi
		     */
		    NonEmployeeLifecycleManagementApi.prototype.approveNonEmployeeRequest = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.NonEmployeeLifecycleManagementApiFp)(this.configuration).approveNonEmployeeRequest(requestParameters.id, requestParameters.nonEmployeeApprovalDecision, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This request will create a non-employee record. Requires role context of `idn:nesr:create`
		     * @summary Create Non-Employee Record
		     * @param {NonEmployeeLifecycleManagementApiCreateNonEmployeeRecordRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof NonEmployeeLifecycleManagementApi
		     */
		    NonEmployeeLifecycleManagementApi.prototype.createNonEmployeeRecord = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.NonEmployeeLifecycleManagementApiFp)(this.configuration).createNonEmployeeRecord(requestParameters.nonEmployeeRequestBody, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This request will create a non-employee request and notify the approver. Requires role context of `idn:nesr:create` or the user must own the source.
		     * @summary Create Non-Employee Request
		     * @param {NonEmployeeLifecycleManagementApiCreateNonEmployeeRequestRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof NonEmployeeLifecycleManagementApi
		     */
		    NonEmployeeLifecycleManagementApi.prototype.createNonEmployeeRequest = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.NonEmployeeLifecycleManagementApiFp)(this.configuration).createNonEmployeeRequest(requestParameters.nonEmployeeRequestBody, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This request will create a non-employee source. Requires role context of `idn:nesr:create`
		     * @summary Create Non-Employee Source
		     * @param {NonEmployeeLifecycleManagementApiCreateNonEmployeeSourceRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof NonEmployeeLifecycleManagementApi
		     */
		    NonEmployeeLifecycleManagementApi.prototype.createNonEmployeeSource = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.NonEmployeeLifecycleManagementApiFp)(this.configuration).createNonEmployeeSource(requestParameters.nonEmployeeSourceRequestBody, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API creates a new schema attribute for Non-Employee Source. The schema technical name must be unique in the source. Attempts to create a schema attribute with an existing name will result in a \"400.1.409 Reference conflict\" response. At most, 10 custom attributes can be created per schema. Attempts to create more than 10 will result in a \"400.1.4 Limit violation\" response. Requires role context of `idn:nesr:create`
		     * @summary Create a new Schema Attribute for Non-Employee Source
		     * @param {NonEmployeeLifecycleManagementApiCreateNonEmployeeSourceSchemaAttributesRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof NonEmployeeLifecycleManagementApi
		     */
		    NonEmployeeLifecycleManagementApi.prototype.createNonEmployeeSourceSchemaAttributes = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.NonEmployeeLifecycleManagementApiFp)(this.configuration).createNonEmployeeSourceSchemaAttributes(requestParameters.sourceId, requestParameters.nonEmployeeSchemaAttributeBody, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This request will delete a non-employee record. Requires role context of `idn:nesr:delete`
		     * @summary Delete Non-Employee Record
		     * @param {NonEmployeeLifecycleManagementApiDeleteNonEmployeeRecordRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof NonEmployeeLifecycleManagementApi
		     */
		    NonEmployeeLifecycleManagementApi.prototype.deleteNonEmployeeRecord = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.NonEmployeeLifecycleManagementApiFp)(this.configuration).deleteNonEmployeeRecord(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This request will delete multiple non-employee records based on the non-employee ids provided. Requires role context of `idn:nesr:delete`
		     * @summary Delete Multiple Non-Employee Records
		     * @param {NonEmployeeLifecycleManagementApiDeleteNonEmployeeRecordsInBulkRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof NonEmployeeLifecycleManagementApi
		     */
		    NonEmployeeLifecycleManagementApi.prototype.deleteNonEmployeeRecordsInBulk = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.NonEmployeeLifecycleManagementApiFp)(this.configuration).deleteNonEmployeeRecordsInBulk(requestParameters.deleteNonEmployeeRecordsInBulkRequest, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This request will delete a non-employee request.  Requires role context of `idn:nesr:delete`
		     * @summary Delete Non-Employee Request
		     * @param {NonEmployeeLifecycleManagementApiDeleteNonEmployeeRequestRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof NonEmployeeLifecycleManagementApi
		     */
		    NonEmployeeLifecycleManagementApi.prototype.deleteNonEmployeeRequest = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.NonEmployeeLifecycleManagementApiFp)(this.configuration).deleteNonEmployeeRequest(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This end-point deletes a specific schema attribute for a non-employee source. Requires role context of `idn:nesr:delete`
		     * @summary Delete a Schema Attribute for Non-Employee Source
		     * @param {NonEmployeeLifecycleManagementApiDeleteNonEmployeeSchemaAttributeRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof NonEmployeeLifecycleManagementApi
		     */
		    NonEmployeeLifecycleManagementApi.prototype.deleteNonEmployeeSchemaAttribute = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.NonEmployeeLifecycleManagementApiFp)(this.configuration).deleteNonEmployeeSchemaAttribute(requestParameters.attributeId, requestParameters.sourceId, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This request will delete a non-employee source. Requires role context of `idn:nesr:delete`.
		     * @summary Delete Non-Employee Source
		     * @param {NonEmployeeLifecycleManagementApiDeleteNonEmployeeSourceRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof NonEmployeeLifecycleManagementApi
		     */
		    NonEmployeeLifecycleManagementApi.prototype.deleteNonEmployeeSource = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.NonEmployeeLifecycleManagementApiFp)(this.configuration).deleteNonEmployeeSource(requestParameters.sourceId, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This end-point deletes all custom schema attributes for a non-employee source. Requires role context of `idn:nesr:delete`
		     * @summary Delete all custom schema attributes for Non-Employee Source
		     * @param {NonEmployeeLifecycleManagementApiDeleteNonEmployeeSourceSchemaAttributesRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof NonEmployeeLifecycleManagementApi
		     */
		    NonEmployeeLifecycleManagementApi.prototype.deleteNonEmployeeSourceSchemaAttributes = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.NonEmployeeLifecycleManagementApiFp)(this.configuration).deleteNonEmployeeSourceSchemaAttributes(requestParameters.sourceId, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This requests a CSV download for all non-employees from a provided source. Requires role context of `idn:nesr:read`
		     * @summary Exports Non-Employee Records to CSV
		     * @param {NonEmployeeLifecycleManagementApiExportNonEmployeeRecordsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof NonEmployeeLifecycleManagementApi
		     */
		    NonEmployeeLifecycleManagementApi.prototype.exportNonEmployeeRecords = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.NonEmployeeLifecycleManagementApiFp)(this.configuration).exportNonEmployeeRecords(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This requests a download for the Source Schema Template for a provided source. Requires role context of `idn:nesr:read`
		     * @summary Exports Source Schema Template
		     * @param {NonEmployeeLifecycleManagementApiExportNonEmployeeSourceSchemaTemplateRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof NonEmployeeLifecycleManagementApi
		     */
		    NonEmployeeLifecycleManagementApi.prototype.exportNonEmployeeSourceSchemaTemplate = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.NonEmployeeLifecycleManagementApiFp)(this.configuration).exportNonEmployeeSourceSchemaTemplate(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Gets a non-employee approval item detail. There are two contextual uses for this endpoint:   1. The user has the role context of `idn:nesr:read`, in which case they can get any approval.   2. The user owns the requested approval.
		     * @summary Get a non-employee approval item detail
		     * @param {NonEmployeeLifecycleManagementApiGetNonEmployeeApprovalRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof NonEmployeeLifecycleManagementApi
		     */
		    NonEmployeeLifecycleManagementApi.prototype.getNonEmployeeApproval = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.NonEmployeeLifecycleManagementApiFp)(this.configuration).getNonEmployeeApproval(requestParameters.id, requestParameters.includeDetail, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This request will retrieve a summary of non-employee approval requests. There are two contextual uses for the `requested-for` path parameter:   1. The user has the role context of `idn:nesr:read`, in which case he or she may request a summary of all non-employee approval requests assigned to a particular approver by passing in that approver\'s id.   2. The current user is an approver, in which case \"me\" should be provided as the `requested-for` value. This will provide the approver with a summary of the approval items assigned to him or her.
		     * @summary Get Summary of Non-Employee Approval Requests
		     * @param {NonEmployeeLifecycleManagementApiGetNonEmployeeApprovalSummaryRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof NonEmployeeLifecycleManagementApi
		     */
		    NonEmployeeLifecycleManagementApi.prototype.getNonEmployeeApprovalSummary = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.NonEmployeeLifecycleManagementApiFp)(this.configuration).getNonEmployeeApprovalSummary(requestParameters.requestedFor, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * The nonEmployeeBulkUploadStatus API returns the status of the newest bulk upload job for the specified source. Requires role context of `idn:nesr:read`
		     * @summary Obtain the status of bulk upload on the source
		     * @param {NonEmployeeLifecycleManagementApiGetNonEmployeeBulkUploadStatusRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof NonEmployeeLifecycleManagementApi
		     */
		    NonEmployeeLifecycleManagementApi.prototype.getNonEmployeeBulkUploadStatus = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.NonEmployeeLifecycleManagementApiFp)(this.configuration).getNonEmployeeBulkUploadStatus(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This gets a non-employee record. Requires role context of `idn:nesr:read`
		     * @summary Get a Non-Employee Record
		     * @param {NonEmployeeLifecycleManagementApiGetNonEmployeeRecordRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof NonEmployeeLifecycleManagementApi
		     */
		    NonEmployeeLifecycleManagementApi.prototype.getNonEmployeeRecord = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.NonEmployeeLifecycleManagementApiFp)(this.configuration).getNonEmployeeRecord(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This gets a non-employee request. There are two contextual uses for this endpoint:   1. The user has the role context of `idn:nesr:read`, in this case the user can get the non-employee request for any user.   2. The user must be the owner of the non-employee request.
		     * @summary Get a Non-Employee Request
		     * @param {NonEmployeeLifecycleManagementApiGetNonEmployeeRequestRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof NonEmployeeLifecycleManagementApi
		     */
		    NonEmployeeLifecycleManagementApi.prototype.getNonEmployeeRequest = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.NonEmployeeLifecycleManagementApiFp)(this.configuration).getNonEmployeeRequest(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This request will retrieve a summary of non-employee requests. There are two contextual uses for the `requested-for` path parameter:   1. The user has the role context of `idn:nesr:read`, in which case he or she may request a summary of all non-employee approval requests assigned to a particular account manager by passing in that manager\'s id.   2. The current user is an account manager, in which case \"me\" should be provided as the `requested-for` value. This will provide the user with a summary of the non-employee requests in the source(s) he or she manages.
		     * @summary Get Summary of Non-Employee Requests
		     * @param {NonEmployeeLifecycleManagementApiGetNonEmployeeRequestSummaryRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof NonEmployeeLifecycleManagementApi
		     */
		    NonEmployeeLifecycleManagementApi.prototype.getNonEmployeeRequestSummary = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.NonEmployeeLifecycleManagementApiFp)(this.configuration).getNonEmployeeRequestSummary(requestParameters.requestedFor, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API gets a schema attribute by Id for the specified Non-Employee SourceId. Requires role context of `idn:nesr:read` or the user must be an account manager of the source.
		     * @summary Get Schema Attribute Non-Employee Source
		     * @param {NonEmployeeLifecycleManagementApiGetNonEmployeeSchemaAttributeRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof NonEmployeeLifecycleManagementApi
		     */
		    NonEmployeeLifecycleManagementApi.prototype.getNonEmployeeSchemaAttribute = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.NonEmployeeLifecycleManagementApiFp)(this.configuration).getNonEmployeeSchemaAttribute(requestParameters.attributeId, requestParameters.sourceId, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This gets a non-employee source. There are two contextual uses for the requested-for path parameter:    1. The user has the role context of `idn:nesr:read`, in which case he or she may request any source.   2. The current user is an account manager, in which case the user can only request sources that they own.
		     * @summary Get a Non-Employee Source
		     * @param {NonEmployeeLifecycleManagementApiGetNonEmployeeSourceRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof NonEmployeeLifecycleManagementApi
		     */
		    NonEmployeeLifecycleManagementApi.prototype.getNonEmployeeSource = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.NonEmployeeLifecycleManagementApiFp)(this.configuration).getNonEmployeeSource(requestParameters.sourceId, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API gets the list of schema attributes for the specified Non-Employee SourceId. There are 8 mandatory attributes added to each new Non-Employee Source automatically. Additionaly, user can add up to 10 custom attributes. This interface returns all the mandatory attributes followed by any custom attributes. At most, a total of 18 attributes will be returned. Requires role context of `idn:nesr:read` or the user must be an account manager of the source.
		     * @summary List Schema Attributes Non-Employee Source
		     * @param {NonEmployeeLifecycleManagementApiGetNonEmployeeSourceSchemaAttributesRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof NonEmployeeLifecycleManagementApi
		     */
		    NonEmployeeLifecycleManagementApi.prototype.getNonEmployeeSourceSchemaAttributes = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.NonEmployeeLifecycleManagementApiFp)(this.configuration).getNonEmployeeSourceSchemaAttributes(requestParameters.sourceId, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This post will import, or update, Non-Employee records found in the CSV. Requires role context of `idn:nesr:create`
		     * @summary Imports, or Updates, Non-Employee Records
		     * @param {NonEmployeeLifecycleManagementApiImportNonEmployeeRecordsInBulkRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof NonEmployeeLifecycleManagementApi
		     */
		    NonEmployeeLifecycleManagementApi.prototype.importNonEmployeeRecordsInBulk = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.NonEmployeeLifecycleManagementApiFp)(this.configuration).importNonEmployeeRecordsInBulk(requestParameters.id, requestParameters.data, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This gets a list of non-employee approval requests. There are two contextual uses for this endpoint:   1. The user has the role context of `idn:nesr:read`, in which case they can list the approvals for any approver.   2. The user owns the requested approval.
		     * @summary Get List of Non-Employee Approval Requests
		     * @param {NonEmployeeLifecycleManagementApiListNonEmployeeApprovalsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof NonEmployeeLifecycleManagementApi
		     */
		    NonEmployeeLifecycleManagementApi.prototype.listNonEmployeeApprovals = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.NonEmployeeLifecycleManagementApiFp)(this.configuration).listNonEmployeeApprovals(requestParameters.requestedFor, requestParameters.limit, requestParameters.offset, requestParameters.count, requestParameters.filters, requestParameters.sorters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This gets a list of non-employee records. There are two contextual uses for this endpoint:   1. The user has the role context of `idn:nesr:read`, in which case they can get a list of all of the non-employees.   2. The user is an account manager, in which case they can get a list of the non-employees that they manage.
		     * @summary List Non-Employee Records
		     * @param {NonEmployeeLifecycleManagementApiListNonEmployeeRecordsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof NonEmployeeLifecycleManagementApi
		     */
		    NonEmployeeLifecycleManagementApi.prototype.listNonEmployeeRecords = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.NonEmployeeLifecycleManagementApiFp)(this.configuration).listNonEmployeeRecords(requestParameters.limit, requestParameters.offset, requestParameters.count, requestParameters.sorters, requestParameters.filters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This gets a list of non-employee requests. There are two contextual uses for the `requested-for` path parameter:   1. The user has the role context of `idn:nesr:read`, in which case he or she may request a list non-employee requests assigned to a particular account manager by passing in that manager\'s id.   2. The current user is an account manager, in which case \"me\" should be provided as the `requested-for` value. This will provide the user with a list of the non-employee requests in the source(s) he or she manages.
		     * @summary List Non-Employee Requests
		     * @param {NonEmployeeLifecycleManagementApiListNonEmployeeRequestsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof NonEmployeeLifecycleManagementApi
		     */
		    NonEmployeeLifecycleManagementApi.prototype.listNonEmployeeRequests = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.NonEmployeeLifecycleManagementApiFp)(this.configuration).listNonEmployeeRequests(requestParameters.requestedFor, requestParameters.limit, requestParameters.offset, requestParameters.count, requestParameters.sorters, requestParameters.filters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This gets a list of non-employee sources. There are two contextual uses for the requested-for path parameter:    1. The user has the role context of `idn:nesr:read`, in which case he or she may request a list sources assigned to a particular account manager by passing in that manager\'s id.   2. The current user is an account manager, in which case \"me\" should be provided as the `requested-for` value. This will provide the user with a list of the sources that he or she owns.
		     * @summary List Non-Employee Sources
		     * @param {NonEmployeeLifecycleManagementApiListNonEmployeeSourcesRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof NonEmployeeLifecycleManagementApi
		     */
		    NonEmployeeLifecycleManagementApi.prototype.listNonEmployeeSources = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.NonEmployeeLifecycleManagementApiFp)(this.configuration).listNonEmployeeSources(requestParameters.requestedFor, requestParameters.limit, requestParameters.offset, requestParameters.count, requestParameters.nonEmployeeCount, requestParameters.sorters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This request will patch a non-employee record. There are two contextual uses for this endpoint:   1. The user has the role context of `idn:nesr:update`, in which case they update all available fields.   2. The user is owner of the source, in this case they can only update the end date.
		     * @summary Patch Non-Employee Record
		     * @param {NonEmployeeLifecycleManagementApiPatchNonEmployeeRecordRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof NonEmployeeLifecycleManagementApi
		     */
		    NonEmployeeLifecycleManagementApi.prototype.patchNonEmployeeRecord = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.NonEmployeeLifecycleManagementApiFp)(this.configuration).patchNonEmployeeRecord(requestParameters.id, requestParameters.jsonPatchOperation, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This end-point patches a specific schema attribute for a non-employee SourceId. Requires role context of `idn:nesr:update`
		     * @summary Patch a Schema Attribute for Non-Employee Source
		     * @param {NonEmployeeLifecycleManagementApiPatchNonEmployeeSchemaAttributeRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof NonEmployeeLifecycleManagementApi
		     */
		    NonEmployeeLifecycleManagementApi.prototype.patchNonEmployeeSchemaAttribute = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.NonEmployeeLifecycleManagementApiFp)(this.configuration).patchNonEmployeeSchemaAttribute(requestParameters.attributeId, requestParameters.sourceId, requestParameters.jsonPatchOperation, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * patch a non-employee source. (partial update) <br/> Patchable field: **name, description, approvers, accountManagers** Requires role context of `idn:nesr:update`.
		     * @summary Patch a Non-Employee Source
		     * @param {NonEmployeeLifecycleManagementApiPatchNonEmployeeSourceRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof NonEmployeeLifecycleManagementApi
		     */
		    NonEmployeeLifecycleManagementApi.prototype.patchNonEmployeeSource = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.NonEmployeeLifecycleManagementApiFp)(this.configuration).patchNonEmployeeSource(requestParameters.sourceId, requestParameters.jsonPatchOperation, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This endpoint will reject an approval item request and notify user. The current user must be the requested approver.
		     * @summary Reject a Non-Employee Request
		     * @param {NonEmployeeLifecycleManagementApiRejectNonEmployeeRequestRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof NonEmployeeLifecycleManagementApi
		     */
		    NonEmployeeLifecycleManagementApi.prototype.rejectNonEmployeeRequest = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.NonEmployeeLifecycleManagementApiFp)(this.configuration).rejectNonEmployeeRequest(requestParameters.id, requestParameters.nonEmployeeRejectApprovalDecision, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This request will update a non-employee record. There are two contextual uses for this endpoint:   1. The user has the role context of `idn:nesr:update`, in which case they update all available fields.   2. The user is owner of the source, in this case they can only update the end date.
		     * @summary Update Non-Employee Record
		     * @param {NonEmployeeLifecycleManagementApiUpdateNonEmployeeRecordRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof NonEmployeeLifecycleManagementApi
		     */
		    NonEmployeeLifecycleManagementApi.prototype.updateNonEmployeeRecord = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.NonEmployeeLifecycleManagementApiFp)(this.configuration).updateNonEmployeeRecord(requestParameters.id, requestParameters.nonEmployeeRequestBody, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return NonEmployeeLifecycleManagementApi;
		}(base_1.BaseAPI));
		exports.NonEmployeeLifecycleManagementApi = NonEmployeeLifecycleManagementApi;
		/**
		 * OAuthClientsApi - axios parameter creator
		 * @export
		 */
		var OAuthClientsApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * This creates an OAuth client.
		         * @summary Create OAuth Client
		         * @param {CreateOAuthClientRequest} createOAuthClientRequest
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createOauthClient: function (createOAuthClientRequest, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'createOAuthClientRequest' is not null or undefined
		                            (0, common_1.assertParamExists)('createOauthClient', 'createOAuthClientRequest', createOAuthClientRequest);
		                            localVarPath = "/oauth-clients";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(createOAuthClientRequest, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This deletes an OAuth client.
		         * @summary Delete OAuth Client
		         * @param {string} id The OAuth client id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteOauthClient: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('deleteOauthClient', 'id', id);
		                            localVarPath = "/oauth-clients/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'DELETE' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets details of an OAuth client.
		         * @summary Get OAuth Client
		         * @param {string} id The OAuth client id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getOauthClient: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getOauthClient', 'id', id);
		                            localVarPath = "/oauth-clients/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets a list of OAuth clients.
		         * @summary List OAuth Clients
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **lastUsed**: *le, isnull*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listOauthClients: function (filters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/oauth-clients";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This performs a targeted update to the field(s) of an OAuth client.
		         * @summary Patch OAuth Client
		         * @param {string} id The OAuth client id
		         * @param {Array<JsonPatchOperation>} jsonPatchOperation A list of OAuth client update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.  The following fields are patchable: * tenant * businessName * homepageUrl * name * description * accessTokenValiditySeconds * refreshTokenValiditySeconds * redirectUris * grantTypes * accessType * enabled * strongAuthSupported * claimsSupported
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchOauthClient: function (id, jsonPatchOperation, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('patchOauthClient', 'id', id);
		                            // verify required parameter 'jsonPatchOperation' is not null or undefined
		                            (0, common_1.assertParamExists)('patchOauthClient', 'jsonPatchOperation', jsonPatchOperation);
		                            localVarPath = "/oauth-clients/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PATCH' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json-patch+json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(jsonPatchOperation, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.OAuthClientsApiAxiosParamCreator = OAuthClientsApiAxiosParamCreator;
		/**
		 * OAuthClientsApi - functional programming interface
		 * @export
		 */
		var OAuthClientsApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.OAuthClientsApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * This creates an OAuth client.
		         * @summary Create OAuth Client
		         * @param {CreateOAuthClientRequest} createOAuthClientRequest
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createOauthClient: function (createOAuthClientRequest, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.createOauthClient(createOAuthClientRequest, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This deletes an OAuth client.
		         * @summary Delete OAuth Client
		         * @param {string} id The OAuth client id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteOauthClient: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.deleteOauthClient(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets details of an OAuth client.
		         * @summary Get OAuth Client
		         * @param {string} id The OAuth client id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getOauthClient: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getOauthClient(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets a list of OAuth clients.
		         * @summary List OAuth Clients
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **lastUsed**: *le, isnull*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listOauthClients: function (filters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listOauthClients(filters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This performs a targeted update to the field(s) of an OAuth client.
		         * @summary Patch OAuth Client
		         * @param {string} id The OAuth client id
		         * @param {Array<JsonPatchOperation>} jsonPatchOperation A list of OAuth client update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.  The following fields are patchable: * tenant * businessName * homepageUrl * name * description * accessTokenValiditySeconds * refreshTokenValiditySeconds * redirectUris * grantTypes * accessType * enabled * strongAuthSupported * claimsSupported
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchOauthClient: function (id, jsonPatchOperation, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.patchOauthClient(id, jsonPatchOperation, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.OAuthClientsApiFp = OAuthClientsApiFp;
		/**
		 * OAuthClientsApi - factory interface
		 * @export
		 */
		var OAuthClientsApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.OAuthClientsApiFp)(configuration);
		    return {
		        /**
		         * This creates an OAuth client.
		         * @summary Create OAuth Client
		         * @param {CreateOAuthClientRequest} createOAuthClientRequest
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createOauthClient: function (createOAuthClientRequest, axiosOptions) {
		            return localVarFp.createOauthClient(createOAuthClientRequest, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This deletes an OAuth client.
		         * @summary Delete OAuth Client
		         * @param {string} id The OAuth client id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteOauthClient: function (id, axiosOptions) {
		            return localVarFp.deleteOauthClient(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This gets details of an OAuth client.
		         * @summary Get OAuth Client
		         * @param {string} id The OAuth client id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getOauthClient: function (id, axiosOptions) {
		            return localVarFp.getOauthClient(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This gets a list of OAuth clients.
		         * @summary List OAuth Clients
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **lastUsed**: *le, isnull*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listOauthClients: function (filters, axiosOptions) {
		            return localVarFp.listOauthClients(filters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This performs a targeted update to the field(s) of an OAuth client.
		         * @summary Patch OAuth Client
		         * @param {string} id The OAuth client id
		         * @param {Array<JsonPatchOperation>} jsonPatchOperation A list of OAuth client update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.  The following fields are patchable: * tenant * businessName * homepageUrl * name * description * accessTokenValiditySeconds * refreshTokenValiditySeconds * redirectUris * grantTypes * accessType * enabled * strongAuthSupported * claimsSupported
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchOauthClient: function (id, jsonPatchOperation, axiosOptions) {
		            return localVarFp.patchOauthClient(id, jsonPatchOperation, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.OAuthClientsApiFactory = OAuthClientsApiFactory;
		/**
		 * OAuthClientsApi - object-oriented interface
		 * @export
		 * @class OAuthClientsApi
		 * @extends {BaseAPI}
		 */
		var OAuthClientsApi = /** @class */ (function (_super) {
		    __extends(OAuthClientsApi, _super);
		    function OAuthClientsApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * This creates an OAuth client.
		     * @summary Create OAuth Client
		     * @param {OAuthClientsApiCreateOauthClientRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof OAuthClientsApi
		     */
		    OAuthClientsApi.prototype.createOauthClient = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.OAuthClientsApiFp)(this.configuration).createOauthClient(requestParameters.createOAuthClientRequest, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This deletes an OAuth client.
		     * @summary Delete OAuth Client
		     * @param {OAuthClientsApiDeleteOauthClientRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof OAuthClientsApi
		     */
		    OAuthClientsApi.prototype.deleteOauthClient = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.OAuthClientsApiFp)(this.configuration).deleteOauthClient(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This gets details of an OAuth client.
		     * @summary Get OAuth Client
		     * @param {OAuthClientsApiGetOauthClientRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof OAuthClientsApi
		     */
		    OAuthClientsApi.prototype.getOauthClient = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.OAuthClientsApiFp)(this.configuration).getOauthClient(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This gets a list of OAuth clients.
		     * @summary List OAuth Clients
		     * @param {OAuthClientsApiListOauthClientsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof OAuthClientsApi
		     */
		    OAuthClientsApi.prototype.listOauthClients = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.OAuthClientsApiFp)(this.configuration).listOauthClients(requestParameters.filters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This performs a targeted update to the field(s) of an OAuth client.
		     * @summary Patch OAuth Client
		     * @param {OAuthClientsApiPatchOauthClientRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof OAuthClientsApi
		     */
		    OAuthClientsApi.prototype.patchOauthClient = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.OAuthClientsApiFp)(this.configuration).patchOauthClient(requestParameters.id, requestParameters.jsonPatchOperation, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return OAuthClientsApi;
		}(base_1.BaseAPI));
		exports.OAuthClientsApi = OAuthClientsApi;
		/**
		 * PasswordConfigurationApi - axios parameter creator
		 * @export
		 */
		var PasswordConfigurationApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * This API creates the password org config. Unspecified fields will use default value. To be able to use the custom password instructions, you must set the `customInstructionsEnabled` field to \"true\". Requires ORG_ADMIN, API role or authorization scope of \'idn:password-org-config:write\'
		         * @summary Create Password Org Config
		         * @param {PasswordOrgConfig} passwordOrgConfig
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createPasswordOrgConfig: function (passwordOrgConfig, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'passwordOrgConfig' is not null or undefined
		                            (0, common_1.assertParamExists)('createPasswordOrgConfig', 'passwordOrgConfig', passwordOrgConfig);
		                            localVarPath = "/password-org-config";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(passwordOrgConfig, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns the password org config . Requires ORG_ADMIN, API role or authorization scope of \'idn:password-org-config:read\'
		         * @summary Get Password Org Config
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getPasswordOrgConfig: function (axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/password-org-config";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API updates the password org config for specified fields. Other fields will keep original value. You must set the `customInstructionsEnabled` field to \"true\" to be able to use custom password instructions.  Requires ORG_ADMIN, API role or authorization scope of \'idn:password-org-config:write\'
		         * @summary Update Password Org Config
		         * @param {PasswordOrgConfig} passwordOrgConfig
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putPasswordOrgConfig: function (passwordOrgConfig, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'passwordOrgConfig' is not null or undefined
		                            (0, common_1.assertParamExists)('putPasswordOrgConfig', 'passwordOrgConfig', passwordOrgConfig);
		                            localVarPath = "/password-org-config";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PUT' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(passwordOrgConfig, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.PasswordConfigurationApiAxiosParamCreator = PasswordConfigurationApiAxiosParamCreator;
		/**
		 * PasswordConfigurationApi - functional programming interface
		 * @export
		 */
		var PasswordConfigurationApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.PasswordConfigurationApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * This API creates the password org config. Unspecified fields will use default value. To be able to use the custom password instructions, you must set the `customInstructionsEnabled` field to \"true\". Requires ORG_ADMIN, API role or authorization scope of \'idn:password-org-config:write\'
		         * @summary Create Password Org Config
		         * @param {PasswordOrgConfig} passwordOrgConfig
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createPasswordOrgConfig: function (passwordOrgConfig, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.createPasswordOrgConfig(passwordOrgConfig, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns the password org config . Requires ORG_ADMIN, API role or authorization scope of \'idn:password-org-config:read\'
		         * @summary Get Password Org Config
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getPasswordOrgConfig: function (axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getPasswordOrgConfig(axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API updates the password org config for specified fields. Other fields will keep original value. You must set the `customInstructionsEnabled` field to \"true\" to be able to use custom password instructions.  Requires ORG_ADMIN, API role or authorization scope of \'idn:password-org-config:write\'
		         * @summary Update Password Org Config
		         * @param {PasswordOrgConfig} passwordOrgConfig
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putPasswordOrgConfig: function (passwordOrgConfig, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.putPasswordOrgConfig(passwordOrgConfig, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.PasswordConfigurationApiFp = PasswordConfigurationApiFp;
		/**
		 * PasswordConfigurationApi - factory interface
		 * @export
		 */
		var PasswordConfigurationApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.PasswordConfigurationApiFp)(configuration);
		    return {
		        /**
		         * This API creates the password org config. Unspecified fields will use default value. To be able to use the custom password instructions, you must set the `customInstructionsEnabled` field to \"true\". Requires ORG_ADMIN, API role or authorization scope of \'idn:password-org-config:write\'
		         * @summary Create Password Org Config
		         * @param {PasswordOrgConfig} passwordOrgConfig
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createPasswordOrgConfig: function (passwordOrgConfig, axiosOptions) {
		            return localVarFp.createPasswordOrgConfig(passwordOrgConfig, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API returns the password org config . Requires ORG_ADMIN, API role or authorization scope of \'idn:password-org-config:read\'
		         * @summary Get Password Org Config
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getPasswordOrgConfig: function (axiosOptions) {
		            return localVarFp.getPasswordOrgConfig(axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API updates the password org config for specified fields. Other fields will keep original value. You must set the `customInstructionsEnabled` field to \"true\" to be able to use custom password instructions.  Requires ORG_ADMIN, API role or authorization scope of \'idn:password-org-config:write\'
		         * @summary Update Password Org Config
		         * @param {PasswordOrgConfig} passwordOrgConfig
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putPasswordOrgConfig: function (passwordOrgConfig, axiosOptions) {
		            return localVarFp.putPasswordOrgConfig(passwordOrgConfig, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.PasswordConfigurationApiFactory = PasswordConfigurationApiFactory;
		/**
		 * PasswordConfigurationApi - object-oriented interface
		 * @export
		 * @class PasswordConfigurationApi
		 * @extends {BaseAPI}
		 */
		var PasswordConfigurationApi = /** @class */ (function (_super) {
		    __extends(PasswordConfigurationApi, _super);
		    function PasswordConfigurationApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * This API creates the password org config. Unspecified fields will use default value. To be able to use the custom password instructions, you must set the `customInstructionsEnabled` field to \"true\". Requires ORG_ADMIN, API role or authorization scope of \'idn:password-org-config:write\'
		     * @summary Create Password Org Config
		     * @param {PasswordConfigurationApiCreatePasswordOrgConfigRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof PasswordConfigurationApi
		     */
		    PasswordConfigurationApi.prototype.createPasswordOrgConfig = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.PasswordConfigurationApiFp)(this.configuration).createPasswordOrgConfig(requestParameters.passwordOrgConfig, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API returns the password org config . Requires ORG_ADMIN, API role or authorization scope of \'idn:password-org-config:read\'
		     * @summary Get Password Org Config
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof PasswordConfigurationApi
		     */
		    PasswordConfigurationApi.prototype.getPasswordOrgConfig = function (axiosOptions) {
		        var _this = this;
		        return (0, exports.PasswordConfigurationApiFp)(this.configuration).getPasswordOrgConfig(axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API updates the password org config for specified fields. Other fields will keep original value. You must set the `customInstructionsEnabled` field to \"true\" to be able to use custom password instructions.  Requires ORG_ADMIN, API role or authorization scope of \'idn:password-org-config:write\'
		     * @summary Update Password Org Config
		     * @param {PasswordConfigurationApiPutPasswordOrgConfigRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof PasswordConfigurationApi
		     */
		    PasswordConfigurationApi.prototype.putPasswordOrgConfig = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.PasswordConfigurationApiFp)(this.configuration).putPasswordOrgConfig(requestParameters.passwordOrgConfig, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return PasswordConfigurationApi;
		}(base_1.BaseAPI));
		exports.PasswordConfigurationApi = PasswordConfigurationApi;
		/**
		 * PasswordDictionaryApi - axios parameter creator
		 * @export
		 */
		var PasswordDictionaryApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * This gets password dictionary for the organization. A token with ORG_ADMIN authority is required to call this API. The password dictionary file can contain lines that are: 1. comment lines - the first character is \'#\', can be 128 Unicode codepoints in length, and are ignored during processing 2. empty lines 3. locale line - the first line that starts with \"locale=\" is considered to be locale line, the rest are treated as normal content lines 4. line containing the password dictionary word - it must start with non-whitespace character and only non-whitespace characters are allowed;         maximum length of the line is 128 Unicode codepoints   Password dictionary file may not contain more than 2,500 lines (not counting whitespace lines, comment lines and locale line).   Password dict file must contain UTF-8 characters only.  # Sample password text file  ```  # Password dictionary small test file  locale=en_US  # Password dictionary prohibited words  qwerty abcd aaaaa password qazxsws  ```
		         * @summary Get Password Dictionary
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getPasswordDictionary: function (axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/password-dictionary";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This updates password dictionary for the organization. A token with ORG_ADMIN authority is required to call this API. The password dictionary file can contain lines that are: 1. comment lines - the first character is \'#\', can be 128 Unicode codepoints in length, and are ignored during processing 2. empty lines 3. locale line - the first line that starts with \"locale=\" is considered to be locale line, the rest are treated as normal content lines 4. line containing the password dictionary word - it must start with non-whitespace character and only non-whitespace characters are allowed;         maximum length of the line is 128 Unicode codepoints   Password dictionary file may not contain more than 2,500 lines (not counting whitespace lines, comment lines and locale line).   Password dict file must contain UTF-8 characters only.  # Sample password text file  ```  # Password dictionary small test file  locale=en_US  # Password dictionary prohibited words  qwerty abcd aaaaa password qazxsws  ```
		         * @summary Update Password Dictionary
		         * @param {any} [file]
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putPasswordDictionary: function (file, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, localVarFormParams, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/password-dictionary";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PUT' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            localVarFormParams = new ((configuration && configuration.formDataCtor) || FormData)();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (file !== undefined) {
		                                localVarFormParams.append('file', file);
		                            }
		                            localVarHeaderParameter['Content-Type'] = 'multipart/form-data';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = localVarFormParams;
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.PasswordDictionaryApiAxiosParamCreator = PasswordDictionaryApiAxiosParamCreator;
		/**
		 * PasswordDictionaryApi - functional programming interface
		 * @export
		 */
		var PasswordDictionaryApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.PasswordDictionaryApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * This gets password dictionary for the organization. A token with ORG_ADMIN authority is required to call this API. The password dictionary file can contain lines that are: 1. comment lines - the first character is \'#\', can be 128 Unicode codepoints in length, and are ignored during processing 2. empty lines 3. locale line - the first line that starts with \"locale=\" is considered to be locale line, the rest are treated as normal content lines 4. line containing the password dictionary word - it must start with non-whitespace character and only non-whitespace characters are allowed;         maximum length of the line is 128 Unicode codepoints   Password dictionary file may not contain more than 2,500 lines (not counting whitespace lines, comment lines and locale line).   Password dict file must contain UTF-8 characters only.  # Sample password text file  ```  # Password dictionary small test file  locale=en_US  # Password dictionary prohibited words  qwerty abcd aaaaa password qazxsws  ```
		         * @summary Get Password Dictionary
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getPasswordDictionary: function (axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getPasswordDictionary(axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This updates password dictionary for the organization. A token with ORG_ADMIN authority is required to call this API. The password dictionary file can contain lines that are: 1. comment lines - the first character is \'#\', can be 128 Unicode codepoints in length, and are ignored during processing 2. empty lines 3. locale line - the first line that starts with \"locale=\" is considered to be locale line, the rest are treated as normal content lines 4. line containing the password dictionary word - it must start with non-whitespace character and only non-whitespace characters are allowed;         maximum length of the line is 128 Unicode codepoints   Password dictionary file may not contain more than 2,500 lines (not counting whitespace lines, comment lines and locale line).   Password dict file must contain UTF-8 characters only.  # Sample password text file  ```  # Password dictionary small test file  locale=en_US  # Password dictionary prohibited words  qwerty abcd aaaaa password qazxsws  ```
		         * @summary Update Password Dictionary
		         * @param {any} [file]
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putPasswordDictionary: function (file, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.putPasswordDictionary(file, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.PasswordDictionaryApiFp = PasswordDictionaryApiFp;
		/**
		 * PasswordDictionaryApi - factory interface
		 * @export
		 */
		var PasswordDictionaryApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.PasswordDictionaryApiFp)(configuration);
		    return {
		        /**
		         * This gets password dictionary for the organization. A token with ORG_ADMIN authority is required to call this API. The password dictionary file can contain lines that are: 1. comment lines - the first character is \'#\', can be 128 Unicode codepoints in length, and are ignored during processing 2. empty lines 3. locale line - the first line that starts with \"locale=\" is considered to be locale line, the rest are treated as normal content lines 4. line containing the password dictionary word - it must start with non-whitespace character and only non-whitespace characters are allowed;         maximum length of the line is 128 Unicode codepoints   Password dictionary file may not contain more than 2,500 lines (not counting whitespace lines, comment lines and locale line).   Password dict file must contain UTF-8 characters only.  # Sample password text file  ```  # Password dictionary small test file  locale=en_US  # Password dictionary prohibited words  qwerty abcd aaaaa password qazxsws  ```
		         * @summary Get Password Dictionary
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getPasswordDictionary: function (axiosOptions) {
		            return localVarFp.getPasswordDictionary(axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This updates password dictionary for the organization. A token with ORG_ADMIN authority is required to call this API. The password dictionary file can contain lines that are: 1. comment lines - the first character is \'#\', can be 128 Unicode codepoints in length, and are ignored during processing 2. empty lines 3. locale line - the first line that starts with \"locale=\" is considered to be locale line, the rest are treated as normal content lines 4. line containing the password dictionary word - it must start with non-whitespace character and only non-whitespace characters are allowed;         maximum length of the line is 128 Unicode codepoints   Password dictionary file may not contain more than 2,500 lines (not counting whitespace lines, comment lines and locale line).   Password dict file must contain UTF-8 characters only.  # Sample password text file  ```  # Password dictionary small test file  locale=en_US  # Password dictionary prohibited words  qwerty abcd aaaaa password qazxsws  ```
		         * @summary Update Password Dictionary
		         * @param {any} [file]
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putPasswordDictionary: function (file, axiosOptions) {
		            return localVarFp.putPasswordDictionary(file, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.PasswordDictionaryApiFactory = PasswordDictionaryApiFactory;
		/**
		 * PasswordDictionaryApi - object-oriented interface
		 * @export
		 * @class PasswordDictionaryApi
		 * @extends {BaseAPI}
		 */
		var PasswordDictionaryApi = /** @class */ (function (_super) {
		    __extends(PasswordDictionaryApi, _super);
		    function PasswordDictionaryApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * This gets password dictionary for the organization. A token with ORG_ADMIN authority is required to call this API. The password dictionary file can contain lines that are: 1. comment lines - the first character is \'#\', can be 128 Unicode codepoints in length, and are ignored during processing 2. empty lines 3. locale line - the first line that starts with \"locale=\" is considered to be locale line, the rest are treated as normal content lines 4. line containing the password dictionary word - it must start with non-whitespace character and only non-whitespace characters are allowed;         maximum length of the line is 128 Unicode codepoints   Password dictionary file may not contain more than 2,500 lines (not counting whitespace lines, comment lines and locale line).   Password dict file must contain UTF-8 characters only.  # Sample password text file  ```  # Password dictionary small test file  locale=en_US  # Password dictionary prohibited words  qwerty abcd aaaaa password qazxsws  ```
		     * @summary Get Password Dictionary
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof PasswordDictionaryApi
		     */
		    PasswordDictionaryApi.prototype.getPasswordDictionary = function (axiosOptions) {
		        var _this = this;
		        return (0, exports.PasswordDictionaryApiFp)(this.configuration).getPasswordDictionary(axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This updates password dictionary for the organization. A token with ORG_ADMIN authority is required to call this API. The password dictionary file can contain lines that are: 1. comment lines - the first character is \'#\', can be 128 Unicode codepoints in length, and are ignored during processing 2. empty lines 3. locale line - the first line that starts with \"locale=\" is considered to be locale line, the rest are treated as normal content lines 4. line containing the password dictionary word - it must start with non-whitespace character and only non-whitespace characters are allowed;         maximum length of the line is 128 Unicode codepoints   Password dictionary file may not contain more than 2,500 lines (not counting whitespace lines, comment lines and locale line).   Password dict file must contain UTF-8 characters only.  # Sample password text file  ```  # Password dictionary small test file  locale=en_US  # Password dictionary prohibited words  qwerty abcd aaaaa password qazxsws  ```
		     * @summary Update Password Dictionary
		     * @param {PasswordDictionaryApiPutPasswordDictionaryRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof PasswordDictionaryApi
		     */
		    PasswordDictionaryApi.prototype.putPasswordDictionary = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.PasswordDictionaryApiFp)(this.configuration).putPasswordDictionary(requestParameters.file, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return PasswordDictionaryApi;
		}(base_1.BaseAPI));
		exports.PasswordDictionaryApi = PasswordDictionaryApi;
		/**
		 * PasswordManagementApi - axios parameter creator
		 * @export
		 */
		var PasswordManagementApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * This API returns the status of a password change request. A token with identity owner or trusted API client application authority is required to call this API.
		         * @summary Get Password Change Request Status
		         * @param {string} id Password change request ID
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getPasswordChangeStatus: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getPasswordChangeStatus', 'id', id);
		                            localVarPath = "/password-change-status/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API is used to query password related information.   A token with [API authority](https://developer.sailpoint.com/idn/api/authentication#client-credentials-grant-flow)  is required to call this API.  \"API authority\" refers to a token that only has the \"client_credentials\"  grant type, and therefore no user context. A [personal access token](https://developer.sailpoint.com/idn/api/authentication#personal-access-tokens)  or a token generated with the [authorization_code](https://developer.sailpoint.com/idn/api/authentication#authorization-code-grant-flow)  grant type will **NOT** work on this endpoint, and a `403 Forbidden` response  will be returned.
		         * @summary Query Password Info
		         * @param {PasswordInfoQueryDTO} passwordInfoQueryDTO
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        queryPasswordInfo: function (passwordInfoQueryDTO, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'passwordInfoQueryDTO' is not null or undefined
		                            (0, common_1.assertParamExists)('queryPasswordInfo', 'passwordInfoQueryDTO', passwordInfoQueryDTO);
		                            localVarPath = "/query-password-info";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(passwordInfoQueryDTO, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API is used to set a password for an identity.   An identity can change their own password (as well as any of their accounts\' passwords) if they use a token generated by their IDN user, such as a [personal access token](https://developer.sailpoint.com/idn/api/authentication#personal-access-tokens) or [\"authorization_code\" derived OAuth token](https://developer.sailpoint.com/idn/api/authentication#authorization-code-grant-flow).  A token with [API authority](https://developer.sailpoint.com/idn/api/authentication#client-credentials-grant-flow) can be used to change **any** identity\'s password or the password of any of the identity\'s accounts.  \"API authority\" refers to a token that only has the \"client_credentials\" grant type.  You can use this endpoint to generate an `encryptedPassword` (RSA encrypted using publicKey).  To do so, follow these steps:  1. Use [Query Password Info](https://developer.sailpoint.com/idn/api/v3/query-password-info) to get the following information: `identityId`, `sourceId`, `publicKeyId`, `publicKey`, `accounts`, and `policies`.   2. Choose an account from the previous response that you will provide as an `accountId` in your request to set an encrypted password.   3. Use [Set Identity\'s Password](https://developer.sailpoint.com/idn/api/v3/set-password) and provide the information you got from your earlier query. Then add this code to your request to get the encrypted password:  ```java import javax.crypto.Cipher; import java.security.KeyFactory; import java.security.PublicKey; import java.security.spec.X509EncodedKeySpec; import java util.Base64;  String encrypt(String publicKey, String toEncrypt) throws Exception {   byte[] publicKeyBytes = Base64.getDecoder().decode(publicKey);   byte[] encryptedBytes = encryptRsa(publicKeyBytes, toEncrypt.getBytes(\"UTF-8\"));   return Base64.getEncoder().encodeToString(encryptedBytes); }  private byte[] encryptRsa(byte[] publicKeyBytes, byte[] toEncryptBytes) throws Exception {   PublicKey key = KeyFactory.getInstance(\"RSA\").generatePublic(new X509EncodedKeySpec(publicKeyBytes));   String transformation = \"RSA/ECB/PKCS1Padding\";   Cipher cipher = Cipher.getInstance(transformation);   cipher.init(1, key);   return cipher.doFinal(toEncryptBytes); } ```      In this example, `toEncrypt` refers to the plain text password you are setting and then encrypting, and the `publicKey` refers to the publicKey you got from the first request you sent.   You can then use [Get Password Change Request Status](https://developer.sailpoint.com/idn/api/v3/get-password-change-status) to check the password change request status. To do so, you must provide the `requestId` from your earlier request to set the password.
		         * @summary Set Identity\'s Password
		         * @param {PasswordChangeRequest} passwordChangeRequest
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        setPassword: function (passwordChangeRequest, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'passwordChangeRequest' is not null or undefined
		                            (0, common_1.assertParamExists)('setPassword', 'passwordChangeRequest', passwordChangeRequest);
		                            localVarPath = "/set-password";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(passwordChangeRequest, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.PasswordManagementApiAxiosParamCreator = PasswordManagementApiAxiosParamCreator;
		/**
		 * PasswordManagementApi - functional programming interface
		 * @export
		 */
		var PasswordManagementApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.PasswordManagementApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * This API returns the status of a password change request. A token with identity owner or trusted API client application authority is required to call this API.
		         * @summary Get Password Change Request Status
		         * @param {string} id Password change request ID
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getPasswordChangeStatus: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getPasswordChangeStatus(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API is used to query password related information.   A token with [API authority](https://developer.sailpoint.com/idn/api/authentication#client-credentials-grant-flow)  is required to call this API.  \"API authority\" refers to a token that only has the \"client_credentials\"  grant type, and therefore no user context. A [personal access token](https://developer.sailpoint.com/idn/api/authentication#personal-access-tokens)  or a token generated with the [authorization_code](https://developer.sailpoint.com/idn/api/authentication#authorization-code-grant-flow)  grant type will **NOT** work on this endpoint, and a `403 Forbidden` response  will be returned.
		         * @summary Query Password Info
		         * @param {PasswordInfoQueryDTO} passwordInfoQueryDTO
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        queryPasswordInfo: function (passwordInfoQueryDTO, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.queryPasswordInfo(passwordInfoQueryDTO, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API is used to set a password for an identity.   An identity can change their own password (as well as any of their accounts\' passwords) if they use a token generated by their IDN user, such as a [personal access token](https://developer.sailpoint.com/idn/api/authentication#personal-access-tokens) or [\"authorization_code\" derived OAuth token](https://developer.sailpoint.com/idn/api/authentication#authorization-code-grant-flow).  A token with [API authority](https://developer.sailpoint.com/idn/api/authentication#client-credentials-grant-flow) can be used to change **any** identity\'s password or the password of any of the identity\'s accounts.  \"API authority\" refers to a token that only has the \"client_credentials\" grant type.  You can use this endpoint to generate an `encryptedPassword` (RSA encrypted using publicKey).  To do so, follow these steps:  1. Use [Query Password Info](https://developer.sailpoint.com/idn/api/v3/query-password-info) to get the following information: `identityId`, `sourceId`, `publicKeyId`, `publicKey`, `accounts`, and `policies`.   2. Choose an account from the previous response that you will provide as an `accountId` in your request to set an encrypted password.   3. Use [Set Identity\'s Password](https://developer.sailpoint.com/idn/api/v3/set-password) and provide the information you got from your earlier query. Then add this code to your request to get the encrypted password:  ```java import javax.crypto.Cipher; import java.security.KeyFactory; import java.security.PublicKey; import java.security.spec.X509EncodedKeySpec; import java util.Base64;  String encrypt(String publicKey, String toEncrypt) throws Exception {   byte[] publicKeyBytes = Base64.getDecoder().decode(publicKey);   byte[] encryptedBytes = encryptRsa(publicKeyBytes, toEncrypt.getBytes(\"UTF-8\"));   return Base64.getEncoder().encodeToString(encryptedBytes); }  private byte[] encryptRsa(byte[] publicKeyBytes, byte[] toEncryptBytes) throws Exception {   PublicKey key = KeyFactory.getInstance(\"RSA\").generatePublic(new X509EncodedKeySpec(publicKeyBytes));   String transformation = \"RSA/ECB/PKCS1Padding\";   Cipher cipher = Cipher.getInstance(transformation);   cipher.init(1, key);   return cipher.doFinal(toEncryptBytes); } ```      In this example, `toEncrypt` refers to the plain text password you are setting and then encrypting, and the `publicKey` refers to the publicKey you got from the first request you sent.   You can then use [Get Password Change Request Status](https://developer.sailpoint.com/idn/api/v3/get-password-change-status) to check the password change request status. To do so, you must provide the `requestId` from your earlier request to set the password.
		         * @summary Set Identity\'s Password
		         * @param {PasswordChangeRequest} passwordChangeRequest
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        setPassword: function (passwordChangeRequest, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.setPassword(passwordChangeRequest, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.PasswordManagementApiFp = PasswordManagementApiFp;
		/**
		 * PasswordManagementApi - factory interface
		 * @export
		 */
		var PasswordManagementApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.PasswordManagementApiFp)(configuration);
		    return {
		        /**
		         * This API returns the status of a password change request. A token with identity owner or trusted API client application authority is required to call this API.
		         * @summary Get Password Change Request Status
		         * @param {string} id Password change request ID
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getPasswordChangeStatus: function (id, axiosOptions) {
		            return localVarFp.getPasswordChangeStatus(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API is used to query password related information.   A token with [API authority](https://developer.sailpoint.com/idn/api/authentication#client-credentials-grant-flow)  is required to call this API.  \"API authority\" refers to a token that only has the \"client_credentials\"  grant type, and therefore no user context. A [personal access token](https://developer.sailpoint.com/idn/api/authentication#personal-access-tokens)  or a token generated with the [authorization_code](https://developer.sailpoint.com/idn/api/authentication#authorization-code-grant-flow)  grant type will **NOT** work on this endpoint, and a `403 Forbidden` response  will be returned.
		         * @summary Query Password Info
		         * @param {PasswordInfoQueryDTO} passwordInfoQueryDTO
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        queryPasswordInfo: function (passwordInfoQueryDTO, axiosOptions) {
		            return localVarFp.queryPasswordInfo(passwordInfoQueryDTO, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API is used to set a password for an identity.   An identity can change their own password (as well as any of their accounts\' passwords) if they use a token generated by their IDN user, such as a [personal access token](https://developer.sailpoint.com/idn/api/authentication#personal-access-tokens) or [\"authorization_code\" derived OAuth token](https://developer.sailpoint.com/idn/api/authentication#authorization-code-grant-flow).  A token with [API authority](https://developer.sailpoint.com/idn/api/authentication#client-credentials-grant-flow) can be used to change **any** identity\'s password or the password of any of the identity\'s accounts.  \"API authority\" refers to a token that only has the \"client_credentials\" grant type.  You can use this endpoint to generate an `encryptedPassword` (RSA encrypted using publicKey).  To do so, follow these steps:  1. Use [Query Password Info](https://developer.sailpoint.com/idn/api/v3/query-password-info) to get the following information: `identityId`, `sourceId`, `publicKeyId`, `publicKey`, `accounts`, and `policies`.   2. Choose an account from the previous response that you will provide as an `accountId` in your request to set an encrypted password.   3. Use [Set Identity\'s Password](https://developer.sailpoint.com/idn/api/v3/set-password) and provide the information you got from your earlier query. Then add this code to your request to get the encrypted password:  ```java import javax.crypto.Cipher; import java.security.KeyFactory; import java.security.PublicKey; import java.security.spec.X509EncodedKeySpec; import java util.Base64;  String encrypt(String publicKey, String toEncrypt) throws Exception {   byte[] publicKeyBytes = Base64.getDecoder().decode(publicKey);   byte[] encryptedBytes = encryptRsa(publicKeyBytes, toEncrypt.getBytes(\"UTF-8\"));   return Base64.getEncoder().encodeToString(encryptedBytes); }  private byte[] encryptRsa(byte[] publicKeyBytes, byte[] toEncryptBytes) throws Exception {   PublicKey key = KeyFactory.getInstance(\"RSA\").generatePublic(new X509EncodedKeySpec(publicKeyBytes));   String transformation = \"RSA/ECB/PKCS1Padding\";   Cipher cipher = Cipher.getInstance(transformation);   cipher.init(1, key);   return cipher.doFinal(toEncryptBytes); } ```      In this example, `toEncrypt` refers to the plain text password you are setting and then encrypting, and the `publicKey` refers to the publicKey you got from the first request you sent.   You can then use [Get Password Change Request Status](https://developer.sailpoint.com/idn/api/v3/get-password-change-status) to check the password change request status. To do so, you must provide the `requestId` from your earlier request to set the password.
		         * @summary Set Identity\'s Password
		         * @param {PasswordChangeRequest} passwordChangeRequest
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        setPassword: function (passwordChangeRequest, axiosOptions) {
		            return localVarFp.setPassword(passwordChangeRequest, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.PasswordManagementApiFactory = PasswordManagementApiFactory;
		/**
		 * PasswordManagementApi - object-oriented interface
		 * @export
		 * @class PasswordManagementApi
		 * @extends {BaseAPI}
		 */
		var PasswordManagementApi = /** @class */ (function (_super) {
		    __extends(PasswordManagementApi, _super);
		    function PasswordManagementApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * This API returns the status of a password change request. A token with identity owner or trusted API client application authority is required to call this API.
		     * @summary Get Password Change Request Status
		     * @param {PasswordManagementApiGetPasswordChangeStatusRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof PasswordManagementApi
		     */
		    PasswordManagementApi.prototype.getPasswordChangeStatus = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.PasswordManagementApiFp)(this.configuration).getPasswordChangeStatus(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API is used to query password related information.   A token with [API authority](https://developer.sailpoint.com/idn/api/authentication#client-credentials-grant-flow)  is required to call this API.  \"API authority\" refers to a token that only has the \"client_credentials\"  grant type, and therefore no user context. A [personal access token](https://developer.sailpoint.com/idn/api/authentication#personal-access-tokens)  or a token generated with the [authorization_code](https://developer.sailpoint.com/idn/api/authentication#authorization-code-grant-flow)  grant type will **NOT** work on this endpoint, and a `403 Forbidden` response  will be returned.
		     * @summary Query Password Info
		     * @param {PasswordManagementApiQueryPasswordInfoRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof PasswordManagementApi
		     */
		    PasswordManagementApi.prototype.queryPasswordInfo = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.PasswordManagementApiFp)(this.configuration).queryPasswordInfo(requestParameters.passwordInfoQueryDTO, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API is used to set a password for an identity.   An identity can change their own password (as well as any of their accounts\' passwords) if they use a token generated by their IDN user, such as a [personal access token](https://developer.sailpoint.com/idn/api/authentication#personal-access-tokens) or [\"authorization_code\" derived OAuth token](https://developer.sailpoint.com/idn/api/authentication#authorization-code-grant-flow).  A token with [API authority](https://developer.sailpoint.com/idn/api/authentication#client-credentials-grant-flow) can be used to change **any** identity\'s password or the password of any of the identity\'s accounts.  \"API authority\" refers to a token that only has the \"client_credentials\" grant type.  You can use this endpoint to generate an `encryptedPassword` (RSA encrypted using publicKey).  To do so, follow these steps:  1. Use [Query Password Info](https://developer.sailpoint.com/idn/api/v3/query-password-info) to get the following information: `identityId`, `sourceId`, `publicKeyId`, `publicKey`, `accounts`, and `policies`.   2. Choose an account from the previous response that you will provide as an `accountId` in your request to set an encrypted password.   3. Use [Set Identity\'s Password](https://developer.sailpoint.com/idn/api/v3/set-password) and provide the information you got from your earlier query. Then add this code to your request to get the encrypted password:  ```java import javax.crypto.Cipher; import java.security.KeyFactory; import java.security.PublicKey; import java.security.spec.X509EncodedKeySpec; import java util.Base64;  String encrypt(String publicKey, String toEncrypt) throws Exception {   byte[] publicKeyBytes = Base64.getDecoder().decode(publicKey);   byte[] encryptedBytes = encryptRsa(publicKeyBytes, toEncrypt.getBytes(\"UTF-8\"));   return Base64.getEncoder().encodeToString(encryptedBytes); }  private byte[] encryptRsa(byte[] publicKeyBytes, byte[] toEncryptBytes) throws Exception {   PublicKey key = KeyFactory.getInstance(\"RSA\").generatePublic(new X509EncodedKeySpec(publicKeyBytes));   String transformation = \"RSA/ECB/PKCS1Padding\";   Cipher cipher = Cipher.getInstance(transformation);   cipher.init(1, key);   return cipher.doFinal(toEncryptBytes); } ```      In this example, `toEncrypt` refers to the plain text password you are setting and then encrypting, and the `publicKey` refers to the publicKey you got from the first request you sent.   You can then use [Get Password Change Request Status](https://developer.sailpoint.com/idn/api/v3/get-password-change-status) to check the password change request status. To do so, you must provide the `requestId` from your earlier request to set the password.
		     * @summary Set Identity\'s Password
		     * @param {PasswordManagementApiSetPasswordRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof PasswordManagementApi
		     */
		    PasswordManagementApi.prototype.setPassword = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.PasswordManagementApiFp)(this.configuration).setPassword(requestParameters.passwordChangeRequest, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return PasswordManagementApi;
		}(base_1.BaseAPI));
		exports.PasswordManagementApi = PasswordManagementApi;
		/**
		 * PasswordSyncGroupsApi - axios parameter creator
		 * @export
		 */
		var PasswordSyncGroupsApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * This API creates a password sync group based on the specifications provided. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Create Password Sync Group
		         * @param {PasswordSyncGroup} passwordSyncGroup
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createPasswordSyncGroup: function (passwordSyncGroup, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'passwordSyncGroup' is not null or undefined
		                            (0, common_1.assertParamExists)('createPasswordSyncGroup', 'passwordSyncGroup', passwordSyncGroup);
		                            localVarPath = "/password-sync-groups";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(passwordSyncGroup, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API deletes the specified password sync group. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Delete Password Sync Group by ID
		         * @param {string} id The ID of password sync group to delete.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deletePasswordSyncGroup: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('deletePasswordSyncGroup', 'id', id);
		                            localVarPath = "/password-sync-groups/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'DELETE' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns the sync group for the specified ID. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Get Password Sync Group by ID
		         * @param {string} id The ID of password sync group to retrieve.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getPasswordSyncGroup: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getPasswordSyncGroup', 'id', id);
		                            localVarPath = "/password-sync-groups/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns a list of password sync groups. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Get Password Sync Group List
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getPasswordSyncGroups: function (limit, offset, count, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/password-sync-groups";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API updates the specified password sync group. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Update Password Sync Group by ID
		         * @param {string} id The ID of password sync group to update.
		         * @param {PasswordSyncGroup} passwordSyncGroup
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updatePasswordSyncGroup: function (id, passwordSyncGroup, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('updatePasswordSyncGroup', 'id', id);
		                            // verify required parameter 'passwordSyncGroup' is not null or undefined
		                            (0, common_1.assertParamExists)('updatePasswordSyncGroup', 'passwordSyncGroup', passwordSyncGroup);
		                            localVarPath = "/password-sync-groups/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PUT' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(passwordSyncGroup, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.PasswordSyncGroupsApiAxiosParamCreator = PasswordSyncGroupsApiAxiosParamCreator;
		/**
		 * PasswordSyncGroupsApi - functional programming interface
		 * @export
		 */
		var PasswordSyncGroupsApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.PasswordSyncGroupsApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * This API creates a password sync group based on the specifications provided. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Create Password Sync Group
		         * @param {PasswordSyncGroup} passwordSyncGroup
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createPasswordSyncGroup: function (passwordSyncGroup, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.createPasswordSyncGroup(passwordSyncGroup, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API deletes the specified password sync group. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Delete Password Sync Group by ID
		         * @param {string} id The ID of password sync group to delete.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deletePasswordSyncGroup: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.deletePasswordSyncGroup(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns the sync group for the specified ID. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Get Password Sync Group by ID
		         * @param {string} id The ID of password sync group to retrieve.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getPasswordSyncGroup: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getPasswordSyncGroup(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns a list of password sync groups. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Get Password Sync Group List
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getPasswordSyncGroups: function (limit, offset, count, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getPasswordSyncGroups(limit, offset, count, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API updates the specified password sync group. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Update Password Sync Group by ID
		         * @param {string} id The ID of password sync group to update.
		         * @param {PasswordSyncGroup} passwordSyncGroup
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updatePasswordSyncGroup: function (id, passwordSyncGroup, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.updatePasswordSyncGroup(id, passwordSyncGroup, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.PasswordSyncGroupsApiFp = PasswordSyncGroupsApiFp;
		/**
		 * PasswordSyncGroupsApi - factory interface
		 * @export
		 */
		var PasswordSyncGroupsApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.PasswordSyncGroupsApiFp)(configuration);
		    return {
		        /**
		         * This API creates a password sync group based on the specifications provided. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Create Password Sync Group
		         * @param {PasswordSyncGroup} passwordSyncGroup
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createPasswordSyncGroup: function (passwordSyncGroup, axiosOptions) {
		            return localVarFp.createPasswordSyncGroup(passwordSyncGroup, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API deletes the specified password sync group. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Delete Password Sync Group by ID
		         * @param {string} id The ID of password sync group to delete.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deletePasswordSyncGroup: function (id, axiosOptions) {
		            return localVarFp.deletePasswordSyncGroup(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API returns the sync group for the specified ID. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Get Password Sync Group by ID
		         * @param {string} id The ID of password sync group to retrieve.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getPasswordSyncGroup: function (id, axiosOptions) {
		            return localVarFp.getPasswordSyncGroup(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API returns a list of password sync groups. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Get Password Sync Group List
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getPasswordSyncGroups: function (limit, offset, count, axiosOptions) {
		            return localVarFp.getPasswordSyncGroups(limit, offset, count, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API updates the specified password sync group. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Update Password Sync Group by ID
		         * @param {string} id The ID of password sync group to update.
		         * @param {PasswordSyncGroup} passwordSyncGroup
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updatePasswordSyncGroup: function (id, passwordSyncGroup, axiosOptions) {
		            return localVarFp.updatePasswordSyncGroup(id, passwordSyncGroup, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.PasswordSyncGroupsApiFactory = PasswordSyncGroupsApiFactory;
		/**
		 * PasswordSyncGroupsApi - object-oriented interface
		 * @export
		 * @class PasswordSyncGroupsApi
		 * @extends {BaseAPI}
		 */
		var PasswordSyncGroupsApi = /** @class */ (function (_super) {
		    __extends(PasswordSyncGroupsApi, _super);
		    function PasswordSyncGroupsApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * This API creates a password sync group based on the specifications provided. A token with ORG_ADMIN authority is required to call this API.
		     * @summary Create Password Sync Group
		     * @param {PasswordSyncGroupsApiCreatePasswordSyncGroupRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof PasswordSyncGroupsApi
		     */
		    PasswordSyncGroupsApi.prototype.createPasswordSyncGroup = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.PasswordSyncGroupsApiFp)(this.configuration).createPasswordSyncGroup(requestParameters.passwordSyncGroup, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API deletes the specified password sync group. A token with ORG_ADMIN authority is required to call this API.
		     * @summary Delete Password Sync Group by ID
		     * @param {PasswordSyncGroupsApiDeletePasswordSyncGroupRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof PasswordSyncGroupsApi
		     */
		    PasswordSyncGroupsApi.prototype.deletePasswordSyncGroup = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.PasswordSyncGroupsApiFp)(this.configuration).deletePasswordSyncGroup(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API returns the sync group for the specified ID. A token with ORG_ADMIN authority is required to call this API.
		     * @summary Get Password Sync Group by ID
		     * @param {PasswordSyncGroupsApiGetPasswordSyncGroupRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof PasswordSyncGroupsApi
		     */
		    PasswordSyncGroupsApi.prototype.getPasswordSyncGroup = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.PasswordSyncGroupsApiFp)(this.configuration).getPasswordSyncGroup(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API returns a list of password sync groups. A token with ORG_ADMIN authority is required to call this API.
		     * @summary Get Password Sync Group List
		     * @param {PasswordSyncGroupsApiGetPasswordSyncGroupsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof PasswordSyncGroupsApi
		     */
		    PasswordSyncGroupsApi.prototype.getPasswordSyncGroups = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.PasswordSyncGroupsApiFp)(this.configuration).getPasswordSyncGroups(requestParameters.limit, requestParameters.offset, requestParameters.count, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API updates the specified password sync group. A token with ORG_ADMIN authority is required to call this API.
		     * @summary Update Password Sync Group by ID
		     * @param {PasswordSyncGroupsApiUpdatePasswordSyncGroupRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof PasswordSyncGroupsApi
		     */
		    PasswordSyncGroupsApi.prototype.updatePasswordSyncGroup = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.PasswordSyncGroupsApiFp)(this.configuration).updatePasswordSyncGroup(requestParameters.id, requestParameters.passwordSyncGroup, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return PasswordSyncGroupsApi;
		}(base_1.BaseAPI));
		exports.PasswordSyncGroupsApi = PasswordSyncGroupsApi;
		/**
		 * PersonalAccessTokensApi - axios parameter creator
		 * @export
		 */
		var PersonalAccessTokensApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * This creates a personal access token.
		         * @summary Create Personal Access Token
		         * @param {CreatePersonalAccessTokenRequest} createPersonalAccessTokenRequest Name and scope of personal access token.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createPersonalAccessToken: function (createPersonalAccessTokenRequest, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'createPersonalAccessTokenRequest' is not null or undefined
		                            (0, common_1.assertParamExists)('createPersonalAccessToken', 'createPersonalAccessTokenRequest', createPersonalAccessTokenRequest);
		                            localVarPath = "/personal-access-tokens";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(createPersonalAccessTokenRequest, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This deletes a personal access token.
		         * @summary Delete Personal Access Token
		         * @param {string} id The personal access token id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deletePersonalAccessToken: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('deletePersonalAccessToken', 'id', id);
		                            localVarPath = "/personal-access-tokens/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'DELETE' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets a collection of personal access tokens associated with the optional `owner-id`.  query parameter. If the `owner-id` query parameter is omitted, all personal access tokens  for a tenant will be retrieved, but the caller must have the \'idn:all-personal-access-tokens:read\' right.
		         * @summary List Personal Access Tokens
		         * @param {string} [ownerId] The identity ID of the owner whose personal access tokens should be listed.  If \&quot;me\&quot;, the caller should have the following right: \&#39;idn:my-personal-access-tokens:read\&#39; If an actual owner ID or if the &#x60;owner-id&#x60; parameter is omitted in the request,  the caller should have the following right: \&#39;idn:all-personal-access-tokens:read\&#39;.  If the caller has the following right, then managed personal access tokens associated with &#x60;owner-id&#x60;  will be retrieved: \&#39;idn:managed-personal-access-tokens:read\&#39;
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **lastUsed**: *le, isnull*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listPersonalAccessTokens: function (ownerId, filters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/personal-access-tokens";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (ownerId !== undefined) {
		                                localVarQueryParameter['owner-id'] = ownerId;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This performs a targeted update to the field(s) of a Personal Access Token.
		         * @summary Patch Personal Access Token
		         * @param {string} id The Personal Access Token id
		         * @param {Array<JsonPatchOperation>} jsonPatchOperation A list of OAuth client update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.  The following fields are patchable: * name * scope
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchPersonalAccessToken: function (id, jsonPatchOperation, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('patchPersonalAccessToken', 'id', id);
		                            // verify required parameter 'jsonPatchOperation' is not null or undefined
		                            (0, common_1.assertParamExists)('patchPersonalAccessToken', 'jsonPatchOperation', jsonPatchOperation);
		                            localVarPath = "/personal-access-tokens/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PATCH' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json-patch+json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(jsonPatchOperation, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.PersonalAccessTokensApiAxiosParamCreator = PersonalAccessTokensApiAxiosParamCreator;
		/**
		 * PersonalAccessTokensApi - functional programming interface
		 * @export
		 */
		var PersonalAccessTokensApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.PersonalAccessTokensApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * This creates a personal access token.
		         * @summary Create Personal Access Token
		         * @param {CreatePersonalAccessTokenRequest} createPersonalAccessTokenRequest Name and scope of personal access token.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createPersonalAccessToken: function (createPersonalAccessTokenRequest, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.createPersonalAccessToken(createPersonalAccessTokenRequest, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This deletes a personal access token.
		         * @summary Delete Personal Access Token
		         * @param {string} id The personal access token id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deletePersonalAccessToken: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.deletePersonalAccessToken(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets a collection of personal access tokens associated with the optional `owner-id`.  query parameter. If the `owner-id` query parameter is omitted, all personal access tokens  for a tenant will be retrieved, but the caller must have the \'idn:all-personal-access-tokens:read\' right.
		         * @summary List Personal Access Tokens
		         * @param {string} [ownerId] The identity ID of the owner whose personal access tokens should be listed.  If \&quot;me\&quot;, the caller should have the following right: \&#39;idn:my-personal-access-tokens:read\&#39; If an actual owner ID or if the &#x60;owner-id&#x60; parameter is omitted in the request,  the caller should have the following right: \&#39;idn:all-personal-access-tokens:read\&#39;.  If the caller has the following right, then managed personal access tokens associated with &#x60;owner-id&#x60;  will be retrieved: \&#39;idn:managed-personal-access-tokens:read\&#39;
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **lastUsed**: *le, isnull*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listPersonalAccessTokens: function (ownerId, filters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listPersonalAccessTokens(ownerId, filters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This performs a targeted update to the field(s) of a Personal Access Token.
		         * @summary Patch Personal Access Token
		         * @param {string} id The Personal Access Token id
		         * @param {Array<JsonPatchOperation>} jsonPatchOperation A list of OAuth client update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.  The following fields are patchable: * name * scope
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchPersonalAccessToken: function (id, jsonPatchOperation, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.patchPersonalAccessToken(id, jsonPatchOperation, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.PersonalAccessTokensApiFp = PersonalAccessTokensApiFp;
		/**
		 * PersonalAccessTokensApi - factory interface
		 * @export
		 */
		var PersonalAccessTokensApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.PersonalAccessTokensApiFp)(configuration);
		    return {
		        /**
		         * This creates a personal access token.
		         * @summary Create Personal Access Token
		         * @param {CreatePersonalAccessTokenRequest} createPersonalAccessTokenRequest Name and scope of personal access token.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createPersonalAccessToken: function (createPersonalAccessTokenRequest, axiosOptions) {
		            return localVarFp.createPersonalAccessToken(createPersonalAccessTokenRequest, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This deletes a personal access token.
		         * @summary Delete Personal Access Token
		         * @param {string} id The personal access token id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deletePersonalAccessToken: function (id, axiosOptions) {
		            return localVarFp.deletePersonalAccessToken(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This gets a collection of personal access tokens associated with the optional `owner-id`.  query parameter. If the `owner-id` query parameter is omitted, all personal access tokens  for a tenant will be retrieved, but the caller must have the \'idn:all-personal-access-tokens:read\' right.
		         * @summary List Personal Access Tokens
		         * @param {string} [ownerId] The identity ID of the owner whose personal access tokens should be listed.  If \&quot;me\&quot;, the caller should have the following right: \&#39;idn:my-personal-access-tokens:read\&#39; If an actual owner ID or if the &#x60;owner-id&#x60; parameter is omitted in the request,  the caller should have the following right: \&#39;idn:all-personal-access-tokens:read\&#39;.  If the caller has the following right, then managed personal access tokens associated with &#x60;owner-id&#x60;  will be retrieved: \&#39;idn:managed-personal-access-tokens:read\&#39;
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **lastUsed**: *le, isnull*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listPersonalAccessTokens: function (ownerId, filters, axiosOptions) {
		            return localVarFp.listPersonalAccessTokens(ownerId, filters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This performs a targeted update to the field(s) of a Personal Access Token.
		         * @summary Patch Personal Access Token
		         * @param {string} id The Personal Access Token id
		         * @param {Array<JsonPatchOperation>} jsonPatchOperation A list of OAuth client update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.  The following fields are patchable: * name * scope
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchPersonalAccessToken: function (id, jsonPatchOperation, axiosOptions) {
		            return localVarFp.patchPersonalAccessToken(id, jsonPatchOperation, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.PersonalAccessTokensApiFactory = PersonalAccessTokensApiFactory;
		/**
		 * PersonalAccessTokensApi - object-oriented interface
		 * @export
		 * @class PersonalAccessTokensApi
		 * @extends {BaseAPI}
		 */
		var PersonalAccessTokensApi = /** @class */ (function (_super) {
		    __extends(PersonalAccessTokensApi, _super);
		    function PersonalAccessTokensApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * This creates a personal access token.
		     * @summary Create Personal Access Token
		     * @param {PersonalAccessTokensApiCreatePersonalAccessTokenRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof PersonalAccessTokensApi
		     */
		    PersonalAccessTokensApi.prototype.createPersonalAccessToken = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.PersonalAccessTokensApiFp)(this.configuration).createPersonalAccessToken(requestParameters.createPersonalAccessTokenRequest, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This deletes a personal access token.
		     * @summary Delete Personal Access Token
		     * @param {PersonalAccessTokensApiDeletePersonalAccessTokenRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof PersonalAccessTokensApi
		     */
		    PersonalAccessTokensApi.prototype.deletePersonalAccessToken = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.PersonalAccessTokensApiFp)(this.configuration).deletePersonalAccessToken(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This gets a collection of personal access tokens associated with the optional `owner-id`.  query parameter. If the `owner-id` query parameter is omitted, all personal access tokens  for a tenant will be retrieved, but the caller must have the \'idn:all-personal-access-tokens:read\' right.
		     * @summary List Personal Access Tokens
		     * @param {PersonalAccessTokensApiListPersonalAccessTokensRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof PersonalAccessTokensApi
		     */
		    PersonalAccessTokensApi.prototype.listPersonalAccessTokens = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.PersonalAccessTokensApiFp)(this.configuration).listPersonalAccessTokens(requestParameters.ownerId, requestParameters.filters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This performs a targeted update to the field(s) of a Personal Access Token.
		     * @summary Patch Personal Access Token
		     * @param {PersonalAccessTokensApiPatchPersonalAccessTokenRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof PersonalAccessTokensApi
		     */
		    PersonalAccessTokensApi.prototype.patchPersonalAccessToken = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.PersonalAccessTokensApiFp)(this.configuration).patchPersonalAccessToken(requestParameters.id, requestParameters.jsonPatchOperation, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return PersonalAccessTokensApi;
		}(base_1.BaseAPI));
		exports.PersonalAccessTokensApi = PersonalAccessTokensApi;
		/**
		 * PublicIdentitiesApi - axios parameter creator
		 * @export
		 */
		var PublicIdentitiesApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         *
		         * @summary Get a list of public identities
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **alias**: *eq, sw*  **email**: *eq, sw*  **firstname**: *eq, sw*  **lastname**: *eq, sw*
		         * @param {boolean} [addCoreFilters] If *true*, only get identities which satisfy ALL the following criteria in addition to any criteria specified by *filters*:   - Should be either correlated or protected.   - Should not be \&quot;spadmin\&quot; or \&quot;cloudadmin\&quot;.   - uid should not be null.   - lastname should not be null.   - email should not be null.
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getPublicIdentities: function (limit, offset, count, filters, addCoreFilters, sorters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/public-identities";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            if (addCoreFilters !== undefined) {
		                                localVarQueryParameter['add-core-filters'] = addCoreFilters;
		                            }
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.PublicIdentitiesApiAxiosParamCreator = PublicIdentitiesApiAxiosParamCreator;
		/**
		 * PublicIdentitiesApi - functional programming interface
		 * @export
		 */
		var PublicIdentitiesApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.PublicIdentitiesApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         *
		         * @summary Get a list of public identities
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **alias**: *eq, sw*  **email**: *eq, sw*  **firstname**: *eq, sw*  **lastname**: *eq, sw*
		         * @param {boolean} [addCoreFilters] If *true*, only get identities which satisfy ALL the following criteria in addition to any criteria specified by *filters*:   - Should be either correlated or protected.   - Should not be \&quot;spadmin\&quot; or \&quot;cloudadmin\&quot;.   - uid should not be null.   - lastname should not be null.   - email should not be null.
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getPublicIdentities: function (limit, offset, count, filters, addCoreFilters, sorters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getPublicIdentities(limit, offset, count, filters, addCoreFilters, sorters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.PublicIdentitiesApiFp = PublicIdentitiesApiFp;
		/**
		 * PublicIdentitiesApi - factory interface
		 * @export
		 */
		var PublicIdentitiesApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.PublicIdentitiesApiFp)(configuration);
		    return {
		        /**
		         *
		         * @summary Get a list of public identities
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **alias**: *eq, sw*  **email**: *eq, sw*  **firstname**: *eq, sw*  **lastname**: *eq, sw*
		         * @param {boolean} [addCoreFilters] If *true*, only get identities which satisfy ALL the following criteria in addition to any criteria specified by *filters*:   - Should be either correlated or protected.   - Should not be \&quot;spadmin\&quot; or \&quot;cloudadmin\&quot;.   - uid should not be null.   - lastname should not be null.   - email should not be null.
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getPublicIdentities: function (limit, offset, count, filters, addCoreFilters, sorters, axiosOptions) {
		            return localVarFp.getPublicIdentities(limit, offset, count, filters, addCoreFilters, sorters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.PublicIdentitiesApiFactory = PublicIdentitiesApiFactory;
		/**
		 * PublicIdentitiesApi - object-oriented interface
		 * @export
		 * @class PublicIdentitiesApi
		 * @extends {BaseAPI}
		 */
		var PublicIdentitiesApi = /** @class */ (function (_super) {
		    __extends(PublicIdentitiesApi, _super);
		    function PublicIdentitiesApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     *
		     * @summary Get a list of public identities
		     * @param {PublicIdentitiesApiGetPublicIdentitiesRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof PublicIdentitiesApi
		     */
		    PublicIdentitiesApi.prototype.getPublicIdentities = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.PublicIdentitiesApiFp)(this.configuration).getPublicIdentities(requestParameters.limit, requestParameters.offset, requestParameters.count, requestParameters.filters, requestParameters.addCoreFilters, requestParameters.sorters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return PublicIdentitiesApi;
		}(base_1.BaseAPI));
		exports.PublicIdentitiesApi = PublicIdentitiesApi;
		/**
		 * PublicIdentitiesConfigApi - axios parameter creator
		 * @export
		 */
		var PublicIdentitiesConfigApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * Returns the publicly visible attributes of an identity available to request approvers for Access Requests and Certification Campaigns. A token with ORG ADMIN authority is required to call this API.
		         * @summary Get the Public Identities Configuration
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getPublicIdentityConfig: function (axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/public-identities-config";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Updates the publicly visible attributes of an identity available to request approvers for Access Requests and Certification Campaigns. A token with ORG ADMIN authority is required to call this API.
		         * @summary Update the Public Identities Configuration
		         * @param {PublicIdentityConfig} publicIdentityConfig
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updatePublicIdentityConfig: function (publicIdentityConfig, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'publicIdentityConfig' is not null or undefined
		                            (0, common_1.assertParamExists)('updatePublicIdentityConfig', 'publicIdentityConfig', publicIdentityConfig);
		                            localVarPath = "/public-identities-config";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PUT' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(publicIdentityConfig, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.PublicIdentitiesConfigApiAxiosParamCreator = PublicIdentitiesConfigApiAxiosParamCreator;
		/**
		 * PublicIdentitiesConfigApi - functional programming interface
		 * @export
		 */
		var PublicIdentitiesConfigApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.PublicIdentitiesConfigApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * Returns the publicly visible attributes of an identity available to request approvers for Access Requests and Certification Campaigns. A token with ORG ADMIN authority is required to call this API.
		         * @summary Get the Public Identities Configuration
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getPublicIdentityConfig: function (axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getPublicIdentityConfig(axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Updates the publicly visible attributes of an identity available to request approvers for Access Requests and Certification Campaigns. A token with ORG ADMIN authority is required to call this API.
		         * @summary Update the Public Identities Configuration
		         * @param {PublicIdentityConfig} publicIdentityConfig
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updatePublicIdentityConfig: function (publicIdentityConfig, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.updatePublicIdentityConfig(publicIdentityConfig, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.PublicIdentitiesConfigApiFp = PublicIdentitiesConfigApiFp;
		/**
		 * PublicIdentitiesConfigApi - factory interface
		 * @export
		 */
		var PublicIdentitiesConfigApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.PublicIdentitiesConfigApiFp)(configuration);
		    return {
		        /**
		         * Returns the publicly visible attributes of an identity available to request approvers for Access Requests and Certification Campaigns. A token with ORG ADMIN authority is required to call this API.
		         * @summary Get the Public Identities Configuration
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getPublicIdentityConfig: function (axiosOptions) {
		            return localVarFp.getPublicIdentityConfig(axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Updates the publicly visible attributes of an identity available to request approvers for Access Requests and Certification Campaigns. A token with ORG ADMIN authority is required to call this API.
		         * @summary Update the Public Identities Configuration
		         * @param {PublicIdentityConfig} publicIdentityConfig
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updatePublicIdentityConfig: function (publicIdentityConfig, axiosOptions) {
		            return localVarFp.updatePublicIdentityConfig(publicIdentityConfig, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.PublicIdentitiesConfigApiFactory = PublicIdentitiesConfigApiFactory;
		/**
		 * PublicIdentitiesConfigApi - object-oriented interface
		 * @export
		 * @class PublicIdentitiesConfigApi
		 * @extends {BaseAPI}
		 */
		var PublicIdentitiesConfigApi = /** @class */ (function (_super) {
		    __extends(PublicIdentitiesConfigApi, _super);
		    function PublicIdentitiesConfigApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * Returns the publicly visible attributes of an identity available to request approvers for Access Requests and Certification Campaigns. A token with ORG ADMIN authority is required to call this API.
		     * @summary Get the Public Identities Configuration
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof PublicIdentitiesConfigApi
		     */
		    PublicIdentitiesConfigApi.prototype.getPublicIdentityConfig = function (axiosOptions) {
		        var _this = this;
		        return (0, exports.PublicIdentitiesConfigApiFp)(this.configuration).getPublicIdentityConfig(axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Updates the publicly visible attributes of an identity available to request approvers for Access Requests and Certification Campaigns. A token with ORG ADMIN authority is required to call this API.
		     * @summary Update the Public Identities Configuration
		     * @param {PublicIdentitiesConfigApiUpdatePublicIdentityConfigRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof PublicIdentitiesConfigApi
		     */
		    PublicIdentitiesConfigApi.prototype.updatePublicIdentityConfig = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.PublicIdentitiesConfigApiFp)(this.configuration).updatePublicIdentityConfig(requestParameters.publicIdentityConfig, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return PublicIdentitiesConfigApi;
		}(base_1.BaseAPI));
		exports.PublicIdentitiesConfigApi = PublicIdentitiesConfigApi;
		/**
		 * ReportsDataExtractionApi - axios parameter creator
		 * @export
		 */
		var ReportsDataExtractionApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * Cancels a running report.
		         * @summary Cancel Report
		         * @param {string} id ID of the running Report to cancel
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        cancelReport: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('cancelReport', 'id', id);
		                            localVarPath = "/reports/{id}/cancel"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Gets a report in file format.
		         * @summary Get Report File
		         * @param {string} taskResultId Unique identifier of the task result which handled report
		         * @param {'csv' | 'pdf'} fileFormat Output format of the requested report file
		         * @param {string} [name] preferred Report file name, by default will be used report name from task result.
		         * @param {boolean} [auditable] Enables auditing for current report download. Will create an audit event and sent it to the REPORT cloud-audit kafka topic.  Event will be created if there is any result present by requested taskResultId.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getReport: function (taskResultId, fileFormat, name, auditable, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'taskResultId' is not null or undefined
		                            (0, common_1.assertParamExists)('getReport', 'taskResultId', taskResultId);
		                            // verify required parameter 'fileFormat' is not null or undefined
		                            (0, common_1.assertParamExists)('getReport', 'fileFormat', fileFormat);
		                            localVarPath = "/reports/{taskResultId}"
		                                .replace("{".concat("taskResultId", "}"), encodeURIComponent(String(taskResultId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (fileFormat !== undefined) {
		                                localVarQueryParameter['fileFormat'] = fileFormat;
		                            }
		                            if (name !== undefined) {
		                                localVarQueryParameter['name'] = name;
		                            }
		                            if (auditable !== undefined) {
		                                localVarQueryParameter['auditable'] = auditable;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Get the report results for a report that was run or is running. Returns empty report result in case there are no active task definitions with used in payload task definition name.
		         * @summary Get Report Result
		         * @param {string} taskResultId Unique identifier of the task result which handled report
		         * @param {boolean} [completed] state of task result to apply ordering when results are fetching from the DB
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getReportResult: function (taskResultId, completed, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'taskResultId' is not null or undefined
		                            (0, common_1.assertParamExists)('getReportResult', 'taskResultId', taskResultId);
		                            localVarPath = "/reports/{taskResultId}/result"
		                                .replace("{".concat("taskResultId", "}"), encodeURIComponent(String(taskResultId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (completed !== undefined) {
		                                localVarQueryParameter['completed'] = completed;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Runs a report according to input report details. If non-concurrent task is already running then it returns, otherwise new task creates and returns.
		         * @summary Run Report
		         * @param {ReportDetails} reportDetails
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        startReport: function (reportDetails, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'reportDetails' is not null or undefined
		                            (0, common_1.assertParamExists)('startReport', 'reportDetails', reportDetails);
		                            localVarPath = "/reports/run";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(reportDetails, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.ReportsDataExtractionApiAxiosParamCreator = ReportsDataExtractionApiAxiosParamCreator;
		/**
		 * ReportsDataExtractionApi - functional programming interface
		 * @export
		 */
		var ReportsDataExtractionApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.ReportsDataExtractionApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * Cancels a running report.
		         * @summary Cancel Report
		         * @param {string} id ID of the running Report to cancel
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        cancelReport: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.cancelReport(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Gets a report in file format.
		         * @summary Get Report File
		         * @param {string} taskResultId Unique identifier of the task result which handled report
		         * @param {'csv' | 'pdf'} fileFormat Output format of the requested report file
		         * @param {string} [name] preferred Report file name, by default will be used report name from task result.
		         * @param {boolean} [auditable] Enables auditing for current report download. Will create an audit event and sent it to the REPORT cloud-audit kafka topic.  Event will be created if there is any result present by requested taskResultId.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getReport: function (taskResultId, fileFormat, name, auditable, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getReport(taskResultId, fileFormat, name, auditable, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Get the report results for a report that was run or is running. Returns empty report result in case there are no active task definitions with used in payload task definition name.
		         * @summary Get Report Result
		         * @param {string} taskResultId Unique identifier of the task result which handled report
		         * @param {boolean} [completed] state of task result to apply ordering when results are fetching from the DB
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getReportResult: function (taskResultId, completed, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getReportResult(taskResultId, completed, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Runs a report according to input report details. If non-concurrent task is already running then it returns, otherwise new task creates and returns.
		         * @summary Run Report
		         * @param {ReportDetails} reportDetails
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        startReport: function (reportDetails, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.startReport(reportDetails, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.ReportsDataExtractionApiFp = ReportsDataExtractionApiFp;
		/**
		 * ReportsDataExtractionApi - factory interface
		 * @export
		 */
		var ReportsDataExtractionApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.ReportsDataExtractionApiFp)(configuration);
		    return {
		        /**
		         * Cancels a running report.
		         * @summary Cancel Report
		         * @param {string} id ID of the running Report to cancel
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        cancelReport: function (id, axiosOptions) {
		            return localVarFp.cancelReport(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Gets a report in file format.
		         * @summary Get Report File
		         * @param {string} taskResultId Unique identifier of the task result which handled report
		         * @param {'csv' | 'pdf'} fileFormat Output format of the requested report file
		         * @param {string} [name] preferred Report file name, by default will be used report name from task result.
		         * @param {boolean} [auditable] Enables auditing for current report download. Will create an audit event and sent it to the REPORT cloud-audit kafka topic.  Event will be created if there is any result present by requested taskResultId.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getReport: function (taskResultId, fileFormat, name, auditable, axiosOptions) {
		            return localVarFp.getReport(taskResultId, fileFormat, name, auditable, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Get the report results for a report that was run or is running. Returns empty report result in case there are no active task definitions with used in payload task definition name.
		         * @summary Get Report Result
		         * @param {string} taskResultId Unique identifier of the task result which handled report
		         * @param {boolean} [completed] state of task result to apply ordering when results are fetching from the DB
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getReportResult: function (taskResultId, completed, axiosOptions) {
		            return localVarFp.getReportResult(taskResultId, completed, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Runs a report according to input report details. If non-concurrent task is already running then it returns, otherwise new task creates and returns.
		         * @summary Run Report
		         * @param {ReportDetails} reportDetails
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        startReport: function (reportDetails, axiosOptions) {
		            return localVarFp.startReport(reportDetails, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.ReportsDataExtractionApiFactory = ReportsDataExtractionApiFactory;
		/**
		 * ReportsDataExtractionApi - object-oriented interface
		 * @export
		 * @class ReportsDataExtractionApi
		 * @extends {BaseAPI}
		 */
		var ReportsDataExtractionApi = /** @class */ (function (_super) {
		    __extends(ReportsDataExtractionApi, _super);
		    function ReportsDataExtractionApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * Cancels a running report.
		     * @summary Cancel Report
		     * @param {ReportsDataExtractionApiCancelReportRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof ReportsDataExtractionApi
		     */
		    ReportsDataExtractionApi.prototype.cancelReport = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.ReportsDataExtractionApiFp)(this.configuration).cancelReport(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Gets a report in file format.
		     * @summary Get Report File
		     * @param {ReportsDataExtractionApiGetReportRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof ReportsDataExtractionApi
		     */
		    ReportsDataExtractionApi.prototype.getReport = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.ReportsDataExtractionApiFp)(this.configuration).getReport(requestParameters.taskResultId, requestParameters.fileFormat, requestParameters.name, requestParameters.auditable, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Get the report results for a report that was run or is running. Returns empty report result in case there are no active task definitions with used in payload task definition name.
		     * @summary Get Report Result
		     * @param {ReportsDataExtractionApiGetReportResultRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof ReportsDataExtractionApi
		     */
		    ReportsDataExtractionApi.prototype.getReportResult = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.ReportsDataExtractionApiFp)(this.configuration).getReportResult(requestParameters.taskResultId, requestParameters.completed, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Runs a report according to input report details. If non-concurrent task is already running then it returns, otherwise new task creates and returns.
		     * @summary Run Report
		     * @param {ReportsDataExtractionApiStartReportRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof ReportsDataExtractionApi
		     */
		    ReportsDataExtractionApi.prototype.startReport = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.ReportsDataExtractionApiFp)(this.configuration).startReport(requestParameters.reportDetails, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return ReportsDataExtractionApi;
		}(base_1.BaseAPI));
		exports.ReportsDataExtractionApi = ReportsDataExtractionApi;
		/**
		 * RequestableObjectsApi - axios parameter creator
		 * @export
		 */
		var RequestableObjectsApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * This endpoint returns a list of acccess items that that can be requested through the Access Request endpoints. Access items are marked with AVAILABLE, PENDING or ASSIGNED with respect to the identity provided using *identity-id* query param. Any authenticated token can call this endpoint to see their requestable access items. A token with ORG_ADMIN authority is required to call this endpoint to return a list of all of the requestable access items for the org or for another identity.
		         * @summary Requestable Objects List
		         * @param {string} [identityId] If present, the value returns only requestable objects for the specified identity.  * Admin users can call this with any identity ID value.  * Non-admin users can only specify *me* or pass their own identity ID value.  * If absent, returns a list of all requestable objects for the tenant. Only admin users can make such a call. In this case, the available, pending, assigned accesses will not be annotated in the result.
		         * @param {Array<RequestableObjectType>} [types] Filters the results to the specified type/types, where each type is one of ROLE or ACCESS_PROFILE. If absent, all types are returned. Support for additional types may be added in the future without notice.
		         * @param {string} [term] It allows searching requestable access items with a partial match on the name or description. If term is provided, then the *filter* query parameter will be ignored.
		         * @param {Array<RequestableObjectRequestStatus>} [statuses] Filters the result to the specified status/statuses, where each status is one of AVAILABLE, ASSIGNED, or PENDING. It is an error to specify this parameter without also specifying an *identity-id* parameter. Additional statuses may be added in the future without notice.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **name**: *eq, in, sw*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listRequestableObjects: function (identityId, types, term, statuses, limit, offset, count, filters, sorters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/requestable-objects";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (identityId !== undefined) {
		                                localVarQueryParameter['identity-id'] = identityId;
		                            }
		                            if (types) {
		                                localVarQueryParameter['types'] = types.join(base_1.COLLECTION_FORMATS.csv);
		                            }
		                            if (term !== undefined) {
		                                localVarQueryParameter['term'] = term;
		                            }
		                            if (statuses) {
		                                localVarQueryParameter['statuses'] = statuses.join(base_1.COLLECTION_FORMATS.csv);
		                            }
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.RequestableObjectsApiAxiosParamCreator = RequestableObjectsApiAxiosParamCreator;
		/**
		 * RequestableObjectsApi - functional programming interface
		 * @export
		 */
		var RequestableObjectsApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.RequestableObjectsApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * This endpoint returns a list of acccess items that that can be requested through the Access Request endpoints. Access items are marked with AVAILABLE, PENDING or ASSIGNED with respect to the identity provided using *identity-id* query param. Any authenticated token can call this endpoint to see their requestable access items. A token with ORG_ADMIN authority is required to call this endpoint to return a list of all of the requestable access items for the org or for another identity.
		         * @summary Requestable Objects List
		         * @param {string} [identityId] If present, the value returns only requestable objects for the specified identity.  * Admin users can call this with any identity ID value.  * Non-admin users can only specify *me* or pass their own identity ID value.  * If absent, returns a list of all requestable objects for the tenant. Only admin users can make such a call. In this case, the available, pending, assigned accesses will not be annotated in the result.
		         * @param {Array<RequestableObjectType>} [types] Filters the results to the specified type/types, where each type is one of ROLE or ACCESS_PROFILE. If absent, all types are returned. Support for additional types may be added in the future without notice.
		         * @param {string} [term] It allows searching requestable access items with a partial match on the name or description. If term is provided, then the *filter* query parameter will be ignored.
		         * @param {Array<RequestableObjectRequestStatus>} [statuses] Filters the result to the specified status/statuses, where each status is one of AVAILABLE, ASSIGNED, or PENDING. It is an error to specify this parameter without also specifying an *identity-id* parameter. Additional statuses may be added in the future without notice.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **name**: *eq, in, sw*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listRequestableObjects: function (identityId, types, term, statuses, limit, offset, count, filters, sorters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listRequestableObjects(identityId, types, term, statuses, limit, offset, count, filters, sorters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.RequestableObjectsApiFp = RequestableObjectsApiFp;
		/**
		 * RequestableObjectsApi - factory interface
		 * @export
		 */
		var RequestableObjectsApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.RequestableObjectsApiFp)(configuration);
		    return {
		        /**
		         * This endpoint returns a list of acccess items that that can be requested through the Access Request endpoints. Access items are marked with AVAILABLE, PENDING or ASSIGNED with respect to the identity provided using *identity-id* query param. Any authenticated token can call this endpoint to see their requestable access items. A token with ORG_ADMIN authority is required to call this endpoint to return a list of all of the requestable access items for the org or for another identity.
		         * @summary Requestable Objects List
		         * @param {string} [identityId] If present, the value returns only requestable objects for the specified identity.  * Admin users can call this with any identity ID value.  * Non-admin users can only specify *me* or pass their own identity ID value.  * If absent, returns a list of all requestable objects for the tenant. Only admin users can make such a call. In this case, the available, pending, assigned accesses will not be annotated in the result.
		         * @param {Array<RequestableObjectType>} [types] Filters the results to the specified type/types, where each type is one of ROLE or ACCESS_PROFILE. If absent, all types are returned. Support for additional types may be added in the future without notice.
		         * @param {string} [term] It allows searching requestable access items with a partial match on the name or description. If term is provided, then the *filter* query parameter will be ignored.
		         * @param {Array<RequestableObjectRequestStatus>} [statuses] Filters the result to the specified status/statuses, where each status is one of AVAILABLE, ASSIGNED, or PENDING. It is an error to specify this parameter without also specifying an *identity-id* parameter. Additional statuses may be added in the future without notice.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **name**: *eq, in, sw*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listRequestableObjects: function (identityId, types, term, statuses, limit, offset, count, filters, sorters, axiosOptions) {
		            return localVarFp.listRequestableObjects(identityId, types, term, statuses, limit, offset, count, filters, sorters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.RequestableObjectsApiFactory = RequestableObjectsApiFactory;
		/**
		 * RequestableObjectsApi - object-oriented interface
		 * @export
		 * @class RequestableObjectsApi
		 * @extends {BaseAPI}
		 */
		var RequestableObjectsApi = /** @class */ (function (_super) {
		    __extends(RequestableObjectsApi, _super);
		    function RequestableObjectsApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * This endpoint returns a list of acccess items that that can be requested through the Access Request endpoints. Access items are marked with AVAILABLE, PENDING or ASSIGNED with respect to the identity provided using *identity-id* query param. Any authenticated token can call this endpoint to see their requestable access items. A token with ORG_ADMIN authority is required to call this endpoint to return a list of all of the requestable access items for the org or for another identity.
		     * @summary Requestable Objects List
		     * @param {RequestableObjectsApiListRequestableObjectsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof RequestableObjectsApi
		     */
		    RequestableObjectsApi.prototype.listRequestableObjects = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.RequestableObjectsApiFp)(this.configuration).listRequestableObjects(requestParameters.identityId, requestParameters.types, requestParameters.term, requestParameters.statuses, requestParameters.limit, requestParameters.offset, requestParameters.count, requestParameters.filters, requestParameters.sorters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return RequestableObjectsApi;
		}(base_1.BaseAPI));
		exports.RequestableObjectsApi = RequestableObjectsApi;
		/**
		 * RolesApi - axios parameter creator
		 * @export
		 */
		var RolesApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * This API creates a role. You must have a token with API, ORG_ADMIN, ROLE_ADMIN, or ROLE_SUBADMIN authority to call this API.  In addition, a ROLE_SUBADMIN may not create a role including an access profile if that access profile is associated with a source the ROLE_SUBADMIN is not associated with themselves.  The maximum supported length for the description field is 2000 characters. Longer descriptions will be preserved for existing roles. However, any new roles as well as any updates to existing descriptions will be limited to 2000 characters.
		         * @summary Create a Role
		         * @param {Role} role
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createRole: function (role, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'role' is not null or undefined
		                            (0, common_1.assertParamExists)('createRole', 'role', role);
		                            localVarPath = "/roles";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(role, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API initiates a bulk deletion of one or more Roles.  A token with API, ORG_ADMIN, ROLE_ADMIN, or ROLE_SUBADMIN authority is required to call this API. In addition, a token with ROLE_SUBADMIN authority may only call this API if all Roles included in the request are associated to Sources with management workgroups of which the ROLE_SUBADMIN is a member.
		         * @summary Delete Role(s)
		         * @param {RoleBulkDeleteRequest} roleBulkDeleteRequest
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteBulkRoles: function (roleBulkDeleteRequest, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'roleBulkDeleteRequest' is not null or undefined
		                            (0, common_1.assertParamExists)('deleteBulkRoles', 'roleBulkDeleteRequest', roleBulkDeleteRequest);
		                            localVarPath = "/roles/bulk-delete";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(roleBulkDeleteRequest, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API deletes a Role by its ID. A token with API, ORG_ADMIN, ROLE_ADMIN, or ROLE_SUBADMIN authority is required to call this API. In addition, a token with ROLE_SUBADMIN authority may only call this API if all Access Profiles included in the Role are associated to Sources with management workgroups of which the ROLE_SUBADMIN is a member.
		         * @summary Delete a Role
		         * @param {string} id ID of the Role
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteRole: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('deleteRole', 'id', id);
		                            localVarPath = "/roles/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'DELETE' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns a Role by its ID.  A token with API, ORG_ADMIN, ROLE_ADMIN, or ROLE_SUBADMIN authority is required to call this API. In addition, a token with ROLE_SUBADMIN authority may only call this API if all Access Profiles included in the Role are associated to Sources with management workgroups of which the ROLE_SUBADMIN is a member.
		         * @summary Get a Role
		         * @param {string} id ID of the Role
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getRole: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getRole', 'id', id);
		                            localVarPath = "/roles/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         *
		         * @summary List Identities assigned a Role
		         * @param {string} id ID of the Role for which the assigned Identities are to be listed
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **aliasName**: *eq, sw*  **email**: *eq, sw*  **name**: *eq, sw, co*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **id, name, aliasName, email**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getRoleAssignedIdentities: function (id, limit, offset, count, filters, sorters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getRoleAssignedIdentities', 'id', id);
		                            localVarPath = "/roles/{id}/assigned-identities"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns a list of Roles.  A token with API, ORG_ADMIN, ROLE_ADMIN, or ROLE_SUBADMIN authority is required to call this API.
		         * @summary List Roles
		         * @param {string} [forSubadmin] If provided, filters the returned list according to what is visible to the indicated ROLE_SUBADMIN Identity. The value of the parameter is either an Identity ID, or the special value **me**, which is shorthand for the calling Identity\&#39;s ID. A 400 Bad Request error is returned if the **for-subadmin** parameter is specified for an Identity that is not a subadmin.
		         * @param {number} [limit] Note that for this API the maximum value for limit is 50. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **name**: *eq, sw*  **created**: *gt, lt, ge, le*  **modified**: *gt, lt, ge, le*  **owner.id**: *eq, in*  **requestable**: *eq*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name, created, modified**
		         * @param {string} [forSegmentIds] If present and not empty, additionally filters Roles to those which are assigned to the Segment(s) with the specified IDs.  If segmentation is currently unavailable, specifying this parameter results in an error.
		         * @param {boolean} [includeUnsegmented] Whether or not the response list should contain unsegmented Roles. If *for-segment-ids* is absent or empty, specifying *include-unsegmented* as false results in an error.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listRoles: function (forSubadmin, limit, offset, count, filters, sorters, forSegmentIds, includeUnsegmented, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/roles";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (forSubadmin !== undefined) {
		                                localVarQueryParameter['for-subadmin'] = forSubadmin;
		                            }
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            if (forSegmentIds !== undefined) {
		                                localVarQueryParameter['for-segment-ids'] = forSegmentIds;
		                            }
		                            if (includeUnsegmented !== undefined) {
		                                localVarQueryParameter['include-unsegmented'] = includeUnsegmented;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API updates an existing Role using [JSON Patch](https://tools.ietf.org/html/rfc6902) syntax.  The following fields are patchable: **name**, **description**, **enabled**, **owner**, **accessProfiles**, **membership**, **requestable**, **accessRequestConfig**, **revokeRequestConfig**, **segments** A token with API, ORG_ADMIN, ROLE_ADMIN, or ROLE_SUBADMIN authority is required to call this API. In addition, a token with ROLE_SUBADMIN authority may only call this API if all Access Profiles included in the Role are associated to Sources with management workgroups of which the ROLE_SUBADMIN is a member. The maximum supported length for the description field is 2000 characters. Longer descriptions will be preserved for existing roles, however, any new roles as well as any updates to existing descriptions will be limited to 2000 characters.
		         * @summary Patch a specified Role
		         * @param {string} id ID of the Role to patch
		         * @param {Array<JsonPatchOperation>} jsonPatchOperation
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchRole: function (id, jsonPatchOperation, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('patchRole', 'id', id);
		                            // verify required parameter 'jsonPatchOperation' is not null or undefined
		                            (0, common_1.assertParamExists)('patchRole', 'jsonPatchOperation', jsonPatchOperation);
		                            localVarPath = "/roles/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PATCH' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json-patch+json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(jsonPatchOperation, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.RolesApiAxiosParamCreator = RolesApiAxiosParamCreator;
		/**
		 * RolesApi - functional programming interface
		 * @export
		 */
		var RolesApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.RolesApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * This API creates a role. You must have a token with API, ORG_ADMIN, ROLE_ADMIN, or ROLE_SUBADMIN authority to call this API.  In addition, a ROLE_SUBADMIN may not create a role including an access profile if that access profile is associated with a source the ROLE_SUBADMIN is not associated with themselves.  The maximum supported length for the description field is 2000 characters. Longer descriptions will be preserved for existing roles. However, any new roles as well as any updates to existing descriptions will be limited to 2000 characters.
		         * @summary Create a Role
		         * @param {Role} role
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createRole: function (role, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.createRole(role, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API initiates a bulk deletion of one or more Roles.  A token with API, ORG_ADMIN, ROLE_ADMIN, or ROLE_SUBADMIN authority is required to call this API. In addition, a token with ROLE_SUBADMIN authority may only call this API if all Roles included in the request are associated to Sources with management workgroups of which the ROLE_SUBADMIN is a member.
		         * @summary Delete Role(s)
		         * @param {RoleBulkDeleteRequest} roleBulkDeleteRequest
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteBulkRoles: function (roleBulkDeleteRequest, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.deleteBulkRoles(roleBulkDeleteRequest, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API deletes a Role by its ID. A token with API, ORG_ADMIN, ROLE_ADMIN, or ROLE_SUBADMIN authority is required to call this API. In addition, a token with ROLE_SUBADMIN authority may only call this API if all Access Profiles included in the Role are associated to Sources with management workgroups of which the ROLE_SUBADMIN is a member.
		         * @summary Delete a Role
		         * @param {string} id ID of the Role
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteRole: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.deleteRole(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns a Role by its ID.  A token with API, ORG_ADMIN, ROLE_ADMIN, or ROLE_SUBADMIN authority is required to call this API. In addition, a token with ROLE_SUBADMIN authority may only call this API if all Access Profiles included in the Role are associated to Sources with management workgroups of which the ROLE_SUBADMIN is a member.
		         * @summary Get a Role
		         * @param {string} id ID of the Role
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getRole: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getRole(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         *
		         * @summary List Identities assigned a Role
		         * @param {string} id ID of the Role for which the assigned Identities are to be listed
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **aliasName**: *eq, sw*  **email**: *eq, sw*  **name**: *eq, sw, co*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **id, name, aliasName, email**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getRoleAssignedIdentities: function (id, limit, offset, count, filters, sorters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getRoleAssignedIdentities(id, limit, offset, count, filters, sorters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns a list of Roles.  A token with API, ORG_ADMIN, ROLE_ADMIN, or ROLE_SUBADMIN authority is required to call this API.
		         * @summary List Roles
		         * @param {string} [forSubadmin] If provided, filters the returned list according to what is visible to the indicated ROLE_SUBADMIN Identity. The value of the parameter is either an Identity ID, or the special value **me**, which is shorthand for the calling Identity\&#39;s ID. A 400 Bad Request error is returned if the **for-subadmin** parameter is specified for an Identity that is not a subadmin.
		         * @param {number} [limit] Note that for this API the maximum value for limit is 50. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **name**: *eq, sw*  **created**: *gt, lt, ge, le*  **modified**: *gt, lt, ge, le*  **owner.id**: *eq, in*  **requestable**: *eq*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name, created, modified**
		         * @param {string} [forSegmentIds] If present and not empty, additionally filters Roles to those which are assigned to the Segment(s) with the specified IDs.  If segmentation is currently unavailable, specifying this parameter results in an error.
		         * @param {boolean} [includeUnsegmented] Whether or not the response list should contain unsegmented Roles. If *for-segment-ids* is absent or empty, specifying *include-unsegmented* as false results in an error.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listRoles: function (forSubadmin, limit, offset, count, filters, sorters, forSegmentIds, includeUnsegmented, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listRoles(forSubadmin, limit, offset, count, filters, sorters, forSegmentIds, includeUnsegmented, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API updates an existing Role using [JSON Patch](https://tools.ietf.org/html/rfc6902) syntax.  The following fields are patchable: **name**, **description**, **enabled**, **owner**, **accessProfiles**, **membership**, **requestable**, **accessRequestConfig**, **revokeRequestConfig**, **segments** A token with API, ORG_ADMIN, ROLE_ADMIN, or ROLE_SUBADMIN authority is required to call this API. In addition, a token with ROLE_SUBADMIN authority may only call this API if all Access Profiles included in the Role are associated to Sources with management workgroups of which the ROLE_SUBADMIN is a member. The maximum supported length for the description field is 2000 characters. Longer descriptions will be preserved for existing roles, however, any new roles as well as any updates to existing descriptions will be limited to 2000 characters.
		         * @summary Patch a specified Role
		         * @param {string} id ID of the Role to patch
		         * @param {Array<JsonPatchOperation>} jsonPatchOperation
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchRole: function (id, jsonPatchOperation, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.patchRole(id, jsonPatchOperation, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.RolesApiFp = RolesApiFp;
		/**
		 * RolesApi - factory interface
		 * @export
		 */
		var RolesApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.RolesApiFp)(configuration);
		    return {
		        /**
		         * This API creates a role. You must have a token with API, ORG_ADMIN, ROLE_ADMIN, or ROLE_SUBADMIN authority to call this API.  In addition, a ROLE_SUBADMIN may not create a role including an access profile if that access profile is associated with a source the ROLE_SUBADMIN is not associated with themselves.  The maximum supported length for the description field is 2000 characters. Longer descriptions will be preserved for existing roles. However, any new roles as well as any updates to existing descriptions will be limited to 2000 characters.
		         * @summary Create a Role
		         * @param {Role} role
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createRole: function (role, axiosOptions) {
		            return localVarFp.createRole(role, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API initiates a bulk deletion of one or more Roles.  A token with API, ORG_ADMIN, ROLE_ADMIN, or ROLE_SUBADMIN authority is required to call this API. In addition, a token with ROLE_SUBADMIN authority may only call this API if all Roles included in the request are associated to Sources with management workgroups of which the ROLE_SUBADMIN is a member.
		         * @summary Delete Role(s)
		         * @param {RoleBulkDeleteRequest} roleBulkDeleteRequest
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteBulkRoles: function (roleBulkDeleteRequest, axiosOptions) {
		            return localVarFp.deleteBulkRoles(roleBulkDeleteRequest, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API deletes a Role by its ID. A token with API, ORG_ADMIN, ROLE_ADMIN, or ROLE_SUBADMIN authority is required to call this API. In addition, a token with ROLE_SUBADMIN authority may only call this API if all Access Profiles included in the Role are associated to Sources with management workgroups of which the ROLE_SUBADMIN is a member.
		         * @summary Delete a Role
		         * @param {string} id ID of the Role
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteRole: function (id, axiosOptions) {
		            return localVarFp.deleteRole(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API returns a Role by its ID.  A token with API, ORG_ADMIN, ROLE_ADMIN, or ROLE_SUBADMIN authority is required to call this API. In addition, a token with ROLE_SUBADMIN authority may only call this API if all Access Profiles included in the Role are associated to Sources with management workgroups of which the ROLE_SUBADMIN is a member.
		         * @summary Get a Role
		         * @param {string} id ID of the Role
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getRole: function (id, axiosOptions) {
		            return localVarFp.getRole(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         *
		         * @summary List Identities assigned a Role
		         * @param {string} id ID of the Role for which the assigned Identities are to be listed
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **aliasName**: *eq, sw*  **email**: *eq, sw*  **name**: *eq, sw, co*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **id, name, aliasName, email**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getRoleAssignedIdentities: function (id, limit, offset, count, filters, sorters, axiosOptions) {
		            return localVarFp.getRoleAssignedIdentities(id, limit, offset, count, filters, sorters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API returns a list of Roles.  A token with API, ORG_ADMIN, ROLE_ADMIN, or ROLE_SUBADMIN authority is required to call this API.
		         * @summary List Roles
		         * @param {string} [forSubadmin] If provided, filters the returned list according to what is visible to the indicated ROLE_SUBADMIN Identity. The value of the parameter is either an Identity ID, or the special value **me**, which is shorthand for the calling Identity\&#39;s ID. A 400 Bad Request error is returned if the **for-subadmin** parameter is specified for an Identity that is not a subadmin.
		         * @param {number} [limit] Note that for this API the maximum value for limit is 50. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **name**: *eq, sw*  **created**: *gt, lt, ge, le*  **modified**: *gt, lt, ge, le*  **owner.id**: *eq, in*  **requestable**: *eq*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name, created, modified**
		         * @param {string} [forSegmentIds] If present and not empty, additionally filters Roles to those which are assigned to the Segment(s) with the specified IDs.  If segmentation is currently unavailable, specifying this parameter results in an error.
		         * @param {boolean} [includeUnsegmented] Whether or not the response list should contain unsegmented Roles. If *for-segment-ids* is absent or empty, specifying *include-unsegmented* as false results in an error.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listRoles: function (forSubadmin, limit, offset, count, filters, sorters, forSegmentIds, includeUnsegmented, axiosOptions) {
		            return localVarFp.listRoles(forSubadmin, limit, offset, count, filters, sorters, forSegmentIds, includeUnsegmented, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API updates an existing Role using [JSON Patch](https://tools.ietf.org/html/rfc6902) syntax.  The following fields are patchable: **name**, **description**, **enabled**, **owner**, **accessProfiles**, **membership**, **requestable**, **accessRequestConfig**, **revokeRequestConfig**, **segments** A token with API, ORG_ADMIN, ROLE_ADMIN, or ROLE_SUBADMIN authority is required to call this API. In addition, a token with ROLE_SUBADMIN authority may only call this API if all Access Profiles included in the Role are associated to Sources with management workgroups of which the ROLE_SUBADMIN is a member. The maximum supported length for the description field is 2000 characters. Longer descriptions will be preserved for existing roles, however, any new roles as well as any updates to existing descriptions will be limited to 2000 characters.
		         * @summary Patch a specified Role
		         * @param {string} id ID of the Role to patch
		         * @param {Array<JsonPatchOperation>} jsonPatchOperation
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchRole: function (id, jsonPatchOperation, axiosOptions) {
		            return localVarFp.patchRole(id, jsonPatchOperation, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.RolesApiFactory = RolesApiFactory;
		/**
		 * RolesApi - object-oriented interface
		 * @export
		 * @class RolesApi
		 * @extends {BaseAPI}
		 */
		var RolesApi = /** @class */ (function (_super) {
		    __extends(RolesApi, _super);
		    function RolesApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * This API creates a role. You must have a token with API, ORG_ADMIN, ROLE_ADMIN, or ROLE_SUBADMIN authority to call this API.  In addition, a ROLE_SUBADMIN may not create a role including an access profile if that access profile is associated with a source the ROLE_SUBADMIN is not associated with themselves.  The maximum supported length for the description field is 2000 characters. Longer descriptions will be preserved for existing roles. However, any new roles as well as any updates to existing descriptions will be limited to 2000 characters.
		     * @summary Create a Role
		     * @param {RolesApiCreateRoleRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof RolesApi
		     */
		    RolesApi.prototype.createRole = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.RolesApiFp)(this.configuration).createRole(requestParameters.role, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API initiates a bulk deletion of one or more Roles.  A token with API, ORG_ADMIN, ROLE_ADMIN, or ROLE_SUBADMIN authority is required to call this API. In addition, a token with ROLE_SUBADMIN authority may only call this API if all Roles included in the request are associated to Sources with management workgroups of which the ROLE_SUBADMIN is a member.
		     * @summary Delete Role(s)
		     * @param {RolesApiDeleteBulkRolesRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof RolesApi
		     */
		    RolesApi.prototype.deleteBulkRoles = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.RolesApiFp)(this.configuration).deleteBulkRoles(requestParameters.roleBulkDeleteRequest, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API deletes a Role by its ID. A token with API, ORG_ADMIN, ROLE_ADMIN, or ROLE_SUBADMIN authority is required to call this API. In addition, a token with ROLE_SUBADMIN authority may only call this API if all Access Profiles included in the Role are associated to Sources with management workgroups of which the ROLE_SUBADMIN is a member.
		     * @summary Delete a Role
		     * @param {RolesApiDeleteRoleRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof RolesApi
		     */
		    RolesApi.prototype.deleteRole = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.RolesApiFp)(this.configuration).deleteRole(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API returns a Role by its ID.  A token with API, ORG_ADMIN, ROLE_ADMIN, or ROLE_SUBADMIN authority is required to call this API. In addition, a token with ROLE_SUBADMIN authority may only call this API if all Access Profiles included in the Role are associated to Sources with management workgroups of which the ROLE_SUBADMIN is a member.
		     * @summary Get a Role
		     * @param {RolesApiGetRoleRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof RolesApi
		     */
		    RolesApi.prototype.getRole = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.RolesApiFp)(this.configuration).getRole(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     *
		     * @summary List Identities assigned a Role
		     * @param {RolesApiGetRoleAssignedIdentitiesRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof RolesApi
		     */
		    RolesApi.prototype.getRoleAssignedIdentities = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.RolesApiFp)(this.configuration).getRoleAssignedIdentities(requestParameters.id, requestParameters.limit, requestParameters.offset, requestParameters.count, requestParameters.filters, requestParameters.sorters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API returns a list of Roles.  A token with API, ORG_ADMIN, ROLE_ADMIN, or ROLE_SUBADMIN authority is required to call this API.
		     * @summary List Roles
		     * @param {RolesApiListRolesRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof RolesApi
		     */
		    RolesApi.prototype.listRoles = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.RolesApiFp)(this.configuration).listRoles(requestParameters.forSubadmin, requestParameters.limit, requestParameters.offset, requestParameters.count, requestParameters.filters, requestParameters.sorters, requestParameters.forSegmentIds, requestParameters.includeUnsegmented, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API updates an existing Role using [JSON Patch](https://tools.ietf.org/html/rfc6902) syntax.  The following fields are patchable: **name**, **description**, **enabled**, **owner**, **accessProfiles**, **membership**, **requestable**, **accessRequestConfig**, **revokeRequestConfig**, **segments** A token with API, ORG_ADMIN, ROLE_ADMIN, or ROLE_SUBADMIN authority is required to call this API. In addition, a token with ROLE_SUBADMIN authority may only call this API if all Access Profiles included in the Role are associated to Sources with management workgroups of which the ROLE_SUBADMIN is a member. The maximum supported length for the description field is 2000 characters. Longer descriptions will be preserved for existing roles, however, any new roles as well as any updates to existing descriptions will be limited to 2000 characters.
		     * @summary Patch a specified Role
		     * @param {RolesApiPatchRoleRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof RolesApi
		     */
		    RolesApi.prototype.patchRole = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.RolesApiFp)(this.configuration).patchRole(requestParameters.id, requestParameters.jsonPatchOperation, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return RolesApi;
		}(base_1.BaseAPI));
		exports.RolesApi = RolesApi;
		/**
		 * SODPolicyApi - axios parameter creator
		 * @export
		 */
		var SODPolicyApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * This creates both General and Conflicting Access Based policy, with a limit of 50 entitlements for each (left & right) criteria for Conflicting Access Based SOD policy. Requires role of ORG_ADMIN.
		         * @summary Create SOD policy
		         * @param {SodPolicy} sodPolicy
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createSodPolicy: function (sodPolicy, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'sodPolicy' is not null or undefined
		                            (0, common_1.assertParamExists)('createSodPolicy', 'sodPolicy', sodPolicy);
		                            localVarPath = "/sod-policies";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(sodPolicy, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This deletes a specified SOD policy. Requires role of ORG_ADMIN.
		         * @summary Delete SOD policy by ID
		         * @param {string} id The ID of the SOD Policy to delete.
		         * @param {boolean} [logical] Indicates whether this is a soft delete (logical true) or a hard delete.  Soft delete marks the policy as deleted and just save it with this status. It could be fully deleted or recovered further.  Hard delete vise versa permanently delete SOD request during this call.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteSodPolicy: function (id, logical, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('deleteSodPolicy', 'id', id);
		                            localVarPath = "/sod-policies/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'DELETE' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (logical !== undefined) {
		                                localVarQueryParameter['logical'] = logical;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This deletes schedule for a specified SOD policy by ID.
		         * @summary Delete SOD policy schedule
		         * @param {string} id The ID of the SOD policy the schedule must be deleted for.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteSodPolicySchedule: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('deleteSodPolicySchedule', 'id', id);
		                            localVarPath = "/sod-policies/{id}/schedule"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'DELETE' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This allows to download a specified named violation report for a given report reference.
		         * @summary Download custom violation report
		         * @param {string} reportResultId The ID of the report reference to download.
		         * @param {string} fileName Custom Name for the  file.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getCustomViolationReport: function (reportResultId, fileName, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'reportResultId' is not null or undefined
		                            (0, common_1.assertParamExists)('getCustomViolationReport', 'reportResultId', reportResultId);
		                            // verify required parameter 'fileName' is not null or undefined
		                            (0, common_1.assertParamExists)('getCustomViolationReport', 'fileName', fileName);
		                            localVarPath = "/sod-violation-report/{reportResultId}/download/{fileName}"
		                                .replace("{".concat("reportResultId", "}"), encodeURIComponent(String(reportResultId)))
		                                .replace("{".concat("fileName", "}"), encodeURIComponent(String(fileName)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This allows to download a violation report for a given report reference.
		         * @summary Download violation report
		         * @param {string} reportResultId The ID of the report reference to download.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getDefaultViolationReport: function (reportResultId, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'reportResultId' is not null or undefined
		                            (0, common_1.assertParamExists)('getDefaultViolationReport', 'reportResultId', reportResultId);
		                            localVarPath = "/sod-violation-report/{reportResultId}/download"
		                                .replace("{".concat("reportResultId", "}"), encodeURIComponent(String(reportResultId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This endpoint gets the status for a violation report for all policy run.
		         * @summary Get multi-report run task status
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getSodAllReportRunStatus: function (axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/sod-violation-report";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets specified SOD policy. Requires role of ORG_ADMIN.
		         * @summary Get SOD policy by ID
		         * @param {string} id The ID of the SOD Policy to retrieve.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getSodPolicy: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getSodPolicy', 'id', id);
		                            localVarPath = "/sod-policies/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This endpoint gets a specified SOD policy\'s schedule.
		         * @summary Get SOD policy schedule
		         * @param {string} id The ID of the SOD policy schedule to retrieve.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getSodPolicySchedule: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getSodPolicySchedule', 'id', id);
		                            localVarPath = "/sod-policies/{id}/schedule"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets the status for a violation report run task that has already been invoked.
		         * @summary Get violation report run status
		         * @param {string} reportResultId The ID of the report reference to retrieve.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getSodViolationReportRunStatus: function (reportResultId, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'reportResultId' is not null or undefined
		                            (0, common_1.assertParamExists)('getSodViolationReportRunStatus', 'reportResultId', reportResultId);
		                            localVarPath = "/sod-policies/sod-violation-report-status/{reportResultId}"
		                                .replace("{".concat("reportResultId", "}"), encodeURIComponent(String(reportResultId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets the status for a violation report run task that has already been invoked.
		         * @summary Get SOD violation report status
		         * @param {string} id The ID of the violation report to retrieve status for.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getSodViolationReportStatus: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getSodViolationReportStatus', 'id', id);
		                            localVarPath = "/sod-policies/{id}/violation-report"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets list of all SOD policies. Requires role of ORG_ADMIN
		         * @summary List SOD policies
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq*  **name**: *eq*  **state**: *eq*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listSodPolicies: function (limit, offset, count, filters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/sod-policies";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Allows updating SOD Policy fields other than [\"id\",\"created\",\"creatorId\",\"policyQuery\",\"type\"] using the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard. Requires role of ORG_ADMIN. This endpoint can only patch CONFLICTING_ACCESS_BASED type policies. Do not use this endpoint to patch general policies - doing so will build an API exception.
		         * @summary Patch SOD policy by ID
		         * @param {string} id The ID of the SOD policy being modified.
		         * @param {Array<JsonPatchOperation>} jsonPatchOperation A list of SOD Policy update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.  The following fields are patchable: * name * description * ownerRef * externalPolicyReference * compensatingControls * correctionAdvice * state * tags * violationOwnerAssignmentConfig * scheduled * conflictingAccessCriteria
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchSodPolicy: function (id, jsonPatchOperation, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('patchSodPolicy', 'id', id);
		                            // verify required parameter 'jsonPatchOperation' is not null or undefined
		                            (0, common_1.assertParamExists)('patchSodPolicy', 'jsonPatchOperation', jsonPatchOperation);
		                            localVarPath = "/sod-policies/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PATCH' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json-patch+json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(jsonPatchOperation, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This updates schedule for a specified SOD policy.
		         * @summary Update SOD Policy schedule
		         * @param {string} id The ID of the SOD policy to update its schedule.
		         * @param {SodPolicySchedule} sodPolicySchedule
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putPolicySchedule: function (id, sodPolicySchedule, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('putPolicySchedule', 'id', id);
		                            // verify required parameter 'sodPolicySchedule' is not null or undefined
		                            (0, common_1.assertParamExists)('putPolicySchedule', 'sodPolicySchedule', sodPolicySchedule);
		                            localVarPath = "/sod-policies/{id}/schedule"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PUT' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(sodPolicySchedule, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This updates a specified SOD policy. Requires role of ORG_ADMIN.
		         * @summary Update SOD policy by ID
		         * @param {string} id The ID of the SOD policy to update.
		         * @param {SodPolicy} sodPolicy
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putSodPolicy: function (id, sodPolicy, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('putSodPolicy', 'id', id);
		                            // verify required parameter 'sodPolicy' is not null or undefined
		                            (0, common_1.assertParamExists)('putSodPolicy', 'sodPolicy', sodPolicy);
		                            localVarPath = "/sod-policies/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PUT' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(sodPolicy, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Runs the scheduled report for the policy retrieved by passed policy ID.  The report schedule is fetched from the policy retrieved by ID.
		         * @summary Evaluate one policy by ID
		         * @param {string} id The SOD policy ID to run.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        startEvaluateSodPolicy: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('startEvaluateSodPolicy', 'id', id);
		                            localVarPath = "/sod-policies/{id}/evaluate"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Runs multi-policy report for the org. If a policy reports more than 5000 violations, the report mentions that the violation limit was exceeded for that policy. If the request is empty, the report runs for all policies. Otherwise, the report runs for only the filtered policy list provided.
		         * @summary Runs all policies for org
		         * @param {MultiPolicyRequest} [multiPolicyRequest]
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        startSodAllPoliciesForOrg: function (multiPolicyRequest, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/sod-violation-report/run";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(multiPolicyRequest, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This invokes processing of violation report for given SOD policy. If the policy reports more than 5000 violations, the report returns with violation limit exceeded message.
		         * @summary Runs SOD policy violation report
		         * @param {string} id The SOD policy ID to run.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        startSodPolicy: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('startSodPolicy', 'id', id);
		                            localVarPath = "/sod-policies/{id}/violation-report/run"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.SODPolicyApiAxiosParamCreator = SODPolicyApiAxiosParamCreator;
		/**
		 * SODPolicyApi - functional programming interface
		 * @export
		 */
		var SODPolicyApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.SODPolicyApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * This creates both General and Conflicting Access Based policy, with a limit of 50 entitlements for each (left & right) criteria for Conflicting Access Based SOD policy. Requires role of ORG_ADMIN.
		         * @summary Create SOD policy
		         * @param {SodPolicy} sodPolicy
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createSodPolicy: function (sodPolicy, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.createSodPolicy(sodPolicy, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This deletes a specified SOD policy. Requires role of ORG_ADMIN.
		         * @summary Delete SOD policy by ID
		         * @param {string} id The ID of the SOD Policy to delete.
		         * @param {boolean} [logical] Indicates whether this is a soft delete (logical true) or a hard delete.  Soft delete marks the policy as deleted and just save it with this status. It could be fully deleted or recovered further.  Hard delete vise versa permanently delete SOD request during this call.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteSodPolicy: function (id, logical, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.deleteSodPolicy(id, logical, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This deletes schedule for a specified SOD policy by ID.
		         * @summary Delete SOD policy schedule
		         * @param {string} id The ID of the SOD policy the schedule must be deleted for.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteSodPolicySchedule: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.deleteSodPolicySchedule(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This allows to download a specified named violation report for a given report reference.
		         * @summary Download custom violation report
		         * @param {string} reportResultId The ID of the report reference to download.
		         * @param {string} fileName Custom Name for the  file.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getCustomViolationReport: function (reportResultId, fileName, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getCustomViolationReport(reportResultId, fileName, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This allows to download a violation report for a given report reference.
		         * @summary Download violation report
		         * @param {string} reportResultId The ID of the report reference to download.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getDefaultViolationReport: function (reportResultId, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getDefaultViolationReport(reportResultId, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This endpoint gets the status for a violation report for all policy run.
		         * @summary Get multi-report run task status
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getSodAllReportRunStatus: function (axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getSodAllReportRunStatus(axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets specified SOD policy. Requires role of ORG_ADMIN.
		         * @summary Get SOD policy by ID
		         * @param {string} id The ID of the SOD Policy to retrieve.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getSodPolicy: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getSodPolicy(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This endpoint gets a specified SOD policy\'s schedule.
		         * @summary Get SOD policy schedule
		         * @param {string} id The ID of the SOD policy schedule to retrieve.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getSodPolicySchedule: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getSodPolicySchedule(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets the status for a violation report run task that has already been invoked.
		         * @summary Get violation report run status
		         * @param {string} reportResultId The ID of the report reference to retrieve.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getSodViolationReportRunStatus: function (reportResultId, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getSodViolationReportRunStatus(reportResultId, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets the status for a violation report run task that has already been invoked.
		         * @summary Get SOD violation report status
		         * @param {string} id The ID of the violation report to retrieve status for.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getSodViolationReportStatus: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getSodViolationReportStatus(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets list of all SOD policies. Requires role of ORG_ADMIN
		         * @summary List SOD policies
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq*  **name**: *eq*  **state**: *eq*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listSodPolicies: function (limit, offset, count, filters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listSodPolicies(limit, offset, count, filters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Allows updating SOD Policy fields other than [\"id\",\"created\",\"creatorId\",\"policyQuery\",\"type\"] using the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard. Requires role of ORG_ADMIN. This endpoint can only patch CONFLICTING_ACCESS_BASED type policies. Do not use this endpoint to patch general policies - doing so will build an API exception.
		         * @summary Patch SOD policy by ID
		         * @param {string} id The ID of the SOD policy being modified.
		         * @param {Array<JsonPatchOperation>} jsonPatchOperation A list of SOD Policy update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.  The following fields are patchable: * name * description * ownerRef * externalPolicyReference * compensatingControls * correctionAdvice * state * tags * violationOwnerAssignmentConfig * scheduled * conflictingAccessCriteria
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchSodPolicy: function (id, jsonPatchOperation, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.patchSodPolicy(id, jsonPatchOperation, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This updates schedule for a specified SOD policy.
		         * @summary Update SOD Policy schedule
		         * @param {string} id The ID of the SOD policy to update its schedule.
		         * @param {SodPolicySchedule} sodPolicySchedule
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putPolicySchedule: function (id, sodPolicySchedule, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.putPolicySchedule(id, sodPolicySchedule, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This updates a specified SOD policy. Requires role of ORG_ADMIN.
		         * @summary Update SOD policy by ID
		         * @param {string} id The ID of the SOD policy to update.
		         * @param {SodPolicy} sodPolicy
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putSodPolicy: function (id, sodPolicy, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.putSodPolicy(id, sodPolicy, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Runs the scheduled report for the policy retrieved by passed policy ID.  The report schedule is fetched from the policy retrieved by ID.
		         * @summary Evaluate one policy by ID
		         * @param {string} id The SOD policy ID to run.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        startEvaluateSodPolicy: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.startEvaluateSodPolicy(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Runs multi-policy report for the org. If a policy reports more than 5000 violations, the report mentions that the violation limit was exceeded for that policy. If the request is empty, the report runs for all policies. Otherwise, the report runs for only the filtered policy list provided.
		         * @summary Runs all policies for org
		         * @param {MultiPolicyRequest} [multiPolicyRequest]
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        startSodAllPoliciesForOrg: function (multiPolicyRequest, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.startSodAllPoliciesForOrg(multiPolicyRequest, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This invokes processing of violation report for given SOD policy. If the policy reports more than 5000 violations, the report returns with violation limit exceeded message.
		         * @summary Runs SOD policy violation report
		         * @param {string} id The SOD policy ID to run.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        startSodPolicy: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.startSodPolicy(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.SODPolicyApiFp = SODPolicyApiFp;
		/**
		 * SODPolicyApi - factory interface
		 * @export
		 */
		var SODPolicyApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.SODPolicyApiFp)(configuration);
		    return {
		        /**
		         * This creates both General and Conflicting Access Based policy, with a limit of 50 entitlements for each (left & right) criteria for Conflicting Access Based SOD policy. Requires role of ORG_ADMIN.
		         * @summary Create SOD policy
		         * @param {SodPolicy} sodPolicy
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createSodPolicy: function (sodPolicy, axiosOptions) {
		            return localVarFp.createSodPolicy(sodPolicy, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This deletes a specified SOD policy. Requires role of ORG_ADMIN.
		         * @summary Delete SOD policy by ID
		         * @param {string} id The ID of the SOD Policy to delete.
		         * @param {boolean} [logical] Indicates whether this is a soft delete (logical true) or a hard delete.  Soft delete marks the policy as deleted and just save it with this status. It could be fully deleted or recovered further.  Hard delete vise versa permanently delete SOD request during this call.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteSodPolicy: function (id, logical, axiosOptions) {
		            return localVarFp.deleteSodPolicy(id, logical, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This deletes schedule for a specified SOD policy by ID.
		         * @summary Delete SOD policy schedule
		         * @param {string} id The ID of the SOD policy the schedule must be deleted for.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteSodPolicySchedule: function (id, axiosOptions) {
		            return localVarFp.deleteSodPolicySchedule(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This allows to download a specified named violation report for a given report reference.
		         * @summary Download custom violation report
		         * @param {string} reportResultId The ID of the report reference to download.
		         * @param {string} fileName Custom Name for the  file.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getCustomViolationReport: function (reportResultId, fileName, axiosOptions) {
		            return localVarFp.getCustomViolationReport(reportResultId, fileName, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This allows to download a violation report for a given report reference.
		         * @summary Download violation report
		         * @param {string} reportResultId The ID of the report reference to download.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getDefaultViolationReport: function (reportResultId, axiosOptions) {
		            return localVarFp.getDefaultViolationReport(reportResultId, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This endpoint gets the status for a violation report for all policy run.
		         * @summary Get multi-report run task status
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getSodAllReportRunStatus: function (axiosOptions) {
		            return localVarFp.getSodAllReportRunStatus(axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This gets specified SOD policy. Requires role of ORG_ADMIN.
		         * @summary Get SOD policy by ID
		         * @param {string} id The ID of the SOD Policy to retrieve.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getSodPolicy: function (id, axiosOptions) {
		            return localVarFp.getSodPolicy(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This endpoint gets a specified SOD policy\'s schedule.
		         * @summary Get SOD policy schedule
		         * @param {string} id The ID of the SOD policy schedule to retrieve.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getSodPolicySchedule: function (id, axiosOptions) {
		            return localVarFp.getSodPolicySchedule(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This gets the status for a violation report run task that has already been invoked.
		         * @summary Get violation report run status
		         * @param {string} reportResultId The ID of the report reference to retrieve.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getSodViolationReportRunStatus: function (reportResultId, axiosOptions) {
		            return localVarFp.getSodViolationReportRunStatus(reportResultId, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This gets the status for a violation report run task that has already been invoked.
		         * @summary Get SOD violation report status
		         * @param {string} id The ID of the violation report to retrieve status for.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getSodViolationReportStatus: function (id, axiosOptions) {
		            return localVarFp.getSodViolationReportStatus(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This gets list of all SOD policies. Requires role of ORG_ADMIN
		         * @summary List SOD policies
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq*  **name**: *eq*  **state**: *eq*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listSodPolicies: function (limit, offset, count, filters, axiosOptions) {
		            return localVarFp.listSodPolicies(limit, offset, count, filters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Allows updating SOD Policy fields other than [\"id\",\"created\",\"creatorId\",\"policyQuery\",\"type\"] using the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard. Requires role of ORG_ADMIN. This endpoint can only patch CONFLICTING_ACCESS_BASED type policies. Do not use this endpoint to patch general policies - doing so will build an API exception.
		         * @summary Patch SOD policy by ID
		         * @param {string} id The ID of the SOD policy being modified.
		         * @param {Array<JsonPatchOperation>} jsonPatchOperation A list of SOD Policy update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.  The following fields are patchable: * name * description * ownerRef * externalPolicyReference * compensatingControls * correctionAdvice * state * tags * violationOwnerAssignmentConfig * scheduled * conflictingAccessCriteria
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchSodPolicy: function (id, jsonPatchOperation, axiosOptions) {
		            return localVarFp.patchSodPolicy(id, jsonPatchOperation, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This updates schedule for a specified SOD policy.
		         * @summary Update SOD Policy schedule
		         * @param {string} id The ID of the SOD policy to update its schedule.
		         * @param {SodPolicySchedule} sodPolicySchedule
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putPolicySchedule: function (id, sodPolicySchedule, axiosOptions) {
		            return localVarFp.putPolicySchedule(id, sodPolicySchedule, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This updates a specified SOD policy. Requires role of ORG_ADMIN.
		         * @summary Update SOD policy by ID
		         * @param {string} id The ID of the SOD policy to update.
		         * @param {SodPolicy} sodPolicy
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putSodPolicy: function (id, sodPolicy, axiosOptions) {
		            return localVarFp.putSodPolicy(id, sodPolicy, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Runs the scheduled report for the policy retrieved by passed policy ID.  The report schedule is fetched from the policy retrieved by ID.
		         * @summary Evaluate one policy by ID
		         * @param {string} id The SOD policy ID to run.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        startEvaluateSodPolicy: function (id, axiosOptions) {
		            return localVarFp.startEvaluateSodPolicy(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Runs multi-policy report for the org. If a policy reports more than 5000 violations, the report mentions that the violation limit was exceeded for that policy. If the request is empty, the report runs for all policies. Otherwise, the report runs for only the filtered policy list provided.
		         * @summary Runs all policies for org
		         * @param {MultiPolicyRequest} [multiPolicyRequest]
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        startSodAllPoliciesForOrg: function (multiPolicyRequest, axiosOptions) {
		            return localVarFp.startSodAllPoliciesForOrg(multiPolicyRequest, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This invokes processing of violation report for given SOD policy. If the policy reports more than 5000 violations, the report returns with violation limit exceeded message.
		         * @summary Runs SOD policy violation report
		         * @param {string} id The SOD policy ID to run.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        startSodPolicy: function (id, axiosOptions) {
		            return localVarFp.startSodPolicy(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.SODPolicyApiFactory = SODPolicyApiFactory;
		/**
		 * SODPolicyApi - object-oriented interface
		 * @export
		 * @class SODPolicyApi
		 * @extends {BaseAPI}
		 */
		var SODPolicyApi = /** @class */ (function (_super) {
		    __extends(SODPolicyApi, _super);
		    function SODPolicyApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * This creates both General and Conflicting Access Based policy, with a limit of 50 entitlements for each (left & right) criteria for Conflicting Access Based SOD policy. Requires role of ORG_ADMIN.
		     * @summary Create SOD policy
		     * @param {SODPolicyApiCreateSodPolicyRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SODPolicyApi
		     */
		    SODPolicyApi.prototype.createSodPolicy = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SODPolicyApiFp)(this.configuration).createSodPolicy(requestParameters.sodPolicy, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This deletes a specified SOD policy. Requires role of ORG_ADMIN.
		     * @summary Delete SOD policy by ID
		     * @param {SODPolicyApiDeleteSodPolicyRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SODPolicyApi
		     */
		    SODPolicyApi.prototype.deleteSodPolicy = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SODPolicyApiFp)(this.configuration).deleteSodPolicy(requestParameters.id, requestParameters.logical, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This deletes schedule for a specified SOD policy by ID.
		     * @summary Delete SOD policy schedule
		     * @param {SODPolicyApiDeleteSodPolicyScheduleRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SODPolicyApi
		     */
		    SODPolicyApi.prototype.deleteSodPolicySchedule = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SODPolicyApiFp)(this.configuration).deleteSodPolicySchedule(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This allows to download a specified named violation report for a given report reference.
		     * @summary Download custom violation report
		     * @param {SODPolicyApiGetCustomViolationReportRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SODPolicyApi
		     */
		    SODPolicyApi.prototype.getCustomViolationReport = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SODPolicyApiFp)(this.configuration).getCustomViolationReport(requestParameters.reportResultId, requestParameters.fileName, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This allows to download a violation report for a given report reference.
		     * @summary Download violation report
		     * @param {SODPolicyApiGetDefaultViolationReportRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SODPolicyApi
		     */
		    SODPolicyApi.prototype.getDefaultViolationReport = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SODPolicyApiFp)(this.configuration).getDefaultViolationReport(requestParameters.reportResultId, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This endpoint gets the status for a violation report for all policy run.
		     * @summary Get multi-report run task status
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SODPolicyApi
		     */
		    SODPolicyApi.prototype.getSodAllReportRunStatus = function (axiosOptions) {
		        var _this = this;
		        return (0, exports.SODPolicyApiFp)(this.configuration).getSodAllReportRunStatus(axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This gets specified SOD policy. Requires role of ORG_ADMIN.
		     * @summary Get SOD policy by ID
		     * @param {SODPolicyApiGetSodPolicyRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SODPolicyApi
		     */
		    SODPolicyApi.prototype.getSodPolicy = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SODPolicyApiFp)(this.configuration).getSodPolicy(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This endpoint gets a specified SOD policy\'s schedule.
		     * @summary Get SOD policy schedule
		     * @param {SODPolicyApiGetSodPolicyScheduleRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SODPolicyApi
		     */
		    SODPolicyApi.prototype.getSodPolicySchedule = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SODPolicyApiFp)(this.configuration).getSodPolicySchedule(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This gets the status for a violation report run task that has already been invoked.
		     * @summary Get violation report run status
		     * @param {SODPolicyApiGetSodViolationReportRunStatusRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SODPolicyApi
		     */
		    SODPolicyApi.prototype.getSodViolationReportRunStatus = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SODPolicyApiFp)(this.configuration).getSodViolationReportRunStatus(requestParameters.reportResultId, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This gets the status for a violation report run task that has already been invoked.
		     * @summary Get SOD violation report status
		     * @param {SODPolicyApiGetSodViolationReportStatusRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SODPolicyApi
		     */
		    SODPolicyApi.prototype.getSodViolationReportStatus = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SODPolicyApiFp)(this.configuration).getSodViolationReportStatus(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This gets list of all SOD policies. Requires role of ORG_ADMIN
		     * @summary List SOD policies
		     * @param {SODPolicyApiListSodPoliciesRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SODPolicyApi
		     */
		    SODPolicyApi.prototype.listSodPolicies = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.SODPolicyApiFp)(this.configuration).listSodPolicies(requestParameters.limit, requestParameters.offset, requestParameters.count, requestParameters.filters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Allows updating SOD Policy fields other than [\"id\",\"created\",\"creatorId\",\"policyQuery\",\"type\"] using the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard. Requires role of ORG_ADMIN. This endpoint can only patch CONFLICTING_ACCESS_BASED type policies. Do not use this endpoint to patch general policies - doing so will build an API exception.
		     * @summary Patch SOD policy by ID
		     * @param {SODPolicyApiPatchSodPolicyRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SODPolicyApi
		     */
		    SODPolicyApi.prototype.patchSodPolicy = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SODPolicyApiFp)(this.configuration).patchSodPolicy(requestParameters.id, requestParameters.jsonPatchOperation, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This updates schedule for a specified SOD policy.
		     * @summary Update SOD Policy schedule
		     * @param {SODPolicyApiPutPolicyScheduleRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SODPolicyApi
		     */
		    SODPolicyApi.prototype.putPolicySchedule = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SODPolicyApiFp)(this.configuration).putPolicySchedule(requestParameters.id, requestParameters.sodPolicySchedule, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This updates a specified SOD policy. Requires role of ORG_ADMIN.
		     * @summary Update SOD policy by ID
		     * @param {SODPolicyApiPutSodPolicyRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SODPolicyApi
		     */
		    SODPolicyApi.prototype.putSodPolicy = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SODPolicyApiFp)(this.configuration).putSodPolicy(requestParameters.id, requestParameters.sodPolicy, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Runs the scheduled report for the policy retrieved by passed policy ID.  The report schedule is fetched from the policy retrieved by ID.
		     * @summary Evaluate one policy by ID
		     * @param {SODPolicyApiStartEvaluateSodPolicyRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SODPolicyApi
		     */
		    SODPolicyApi.prototype.startEvaluateSodPolicy = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SODPolicyApiFp)(this.configuration).startEvaluateSodPolicy(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Runs multi-policy report for the org. If a policy reports more than 5000 violations, the report mentions that the violation limit was exceeded for that policy. If the request is empty, the report runs for all policies. Otherwise, the report runs for only the filtered policy list provided.
		     * @summary Runs all policies for org
		     * @param {SODPolicyApiStartSodAllPoliciesForOrgRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SODPolicyApi
		     */
		    SODPolicyApi.prototype.startSodAllPoliciesForOrg = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.SODPolicyApiFp)(this.configuration).startSodAllPoliciesForOrg(requestParameters.multiPolicyRequest, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This invokes processing of violation report for given SOD policy. If the policy reports more than 5000 violations, the report returns with violation limit exceeded message.
		     * @summary Runs SOD policy violation report
		     * @param {SODPolicyApiStartSodPolicyRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SODPolicyApi
		     */
		    SODPolicyApi.prototype.startSodPolicy = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SODPolicyApiFp)(this.configuration).startSodPolicy(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return SODPolicyApi;
		}(base_1.BaseAPI));
		exports.SODPolicyApi = SODPolicyApi;
		/**
		 * SODViolationsApi - axios parameter creator
		 * @export
		 */
		var SODViolationsApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * This API is used to check if granting some additional accesses would cause the subject to be in violation of any SOD policies. Returns the violations that would be caused.  A token with ORG_ADMIN or API authority is required to call this API.
		         * @summary Predict SOD violations for identity.
		         * @param {IdentityWithNewAccess} identityWithNewAccess
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        startPredictSodViolations: function (identityWithNewAccess, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'identityWithNewAccess' is not null or undefined
		                            (0, common_1.assertParamExists)('startPredictSodViolations', 'identityWithNewAccess', identityWithNewAccess);
		                            localVarPath = "/sod-violations/predict";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(identityWithNewAccess, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API initiates a SOD policy verification asynchronously.  A token with ORG_ADMIN authority is required to call this API.
		         * @summary Check SOD violations
		         * @param {IdentityWithNewAccess1} identityWithNewAccess1
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        startViolationCheck: function (identityWithNewAccess1, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'identityWithNewAccess1' is not null or undefined
		                            (0, common_1.assertParamExists)('startViolationCheck', 'identityWithNewAccess1', identityWithNewAccess1);
		                            localVarPath = "/sod-violations/check";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(identityWithNewAccess1, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.SODViolationsApiAxiosParamCreator = SODViolationsApiAxiosParamCreator;
		/**
		 * SODViolationsApi - functional programming interface
		 * @export
		 */
		var SODViolationsApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.SODViolationsApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * This API is used to check if granting some additional accesses would cause the subject to be in violation of any SOD policies. Returns the violations that would be caused.  A token with ORG_ADMIN or API authority is required to call this API.
		         * @summary Predict SOD violations for identity.
		         * @param {IdentityWithNewAccess} identityWithNewAccess
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        startPredictSodViolations: function (identityWithNewAccess, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.startPredictSodViolations(identityWithNewAccess, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API initiates a SOD policy verification asynchronously.  A token with ORG_ADMIN authority is required to call this API.
		         * @summary Check SOD violations
		         * @param {IdentityWithNewAccess1} identityWithNewAccess1
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        startViolationCheck: function (identityWithNewAccess1, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.startViolationCheck(identityWithNewAccess1, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.SODViolationsApiFp = SODViolationsApiFp;
		/**
		 * SODViolationsApi - factory interface
		 * @export
		 */
		var SODViolationsApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.SODViolationsApiFp)(configuration);
		    return {
		        /**
		         * This API is used to check if granting some additional accesses would cause the subject to be in violation of any SOD policies. Returns the violations that would be caused.  A token with ORG_ADMIN or API authority is required to call this API.
		         * @summary Predict SOD violations for identity.
		         * @param {IdentityWithNewAccess} identityWithNewAccess
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        startPredictSodViolations: function (identityWithNewAccess, axiosOptions) {
		            return localVarFp.startPredictSodViolations(identityWithNewAccess, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API initiates a SOD policy verification asynchronously.  A token with ORG_ADMIN authority is required to call this API.
		         * @summary Check SOD violations
		         * @param {IdentityWithNewAccess1} identityWithNewAccess1
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        startViolationCheck: function (identityWithNewAccess1, axiosOptions) {
		            return localVarFp.startViolationCheck(identityWithNewAccess1, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.SODViolationsApiFactory = SODViolationsApiFactory;
		/**
		 * SODViolationsApi - object-oriented interface
		 * @export
		 * @class SODViolationsApi
		 * @extends {BaseAPI}
		 */
		var SODViolationsApi = /** @class */ (function (_super) {
		    __extends(SODViolationsApi, _super);
		    function SODViolationsApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * This API is used to check if granting some additional accesses would cause the subject to be in violation of any SOD policies. Returns the violations that would be caused.  A token with ORG_ADMIN or API authority is required to call this API.
		     * @summary Predict SOD violations for identity.
		     * @param {SODViolationsApiStartPredictSodViolationsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SODViolationsApi
		     */
		    SODViolationsApi.prototype.startPredictSodViolations = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SODViolationsApiFp)(this.configuration).startPredictSodViolations(requestParameters.identityWithNewAccess, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API initiates a SOD policy verification asynchronously.  A token with ORG_ADMIN authority is required to call this API.
		     * @summary Check SOD violations
		     * @param {SODViolationsApiStartViolationCheckRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SODViolationsApi
		     */
		    SODViolationsApi.prototype.startViolationCheck = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SODViolationsApiFp)(this.configuration).startViolationCheck(requestParameters.identityWithNewAccess1, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return SODViolationsApi;
		}(base_1.BaseAPI));
		exports.SODViolationsApi = SODViolationsApi;
		/**
		 * SavedSearchApi - axios parameter creator
		 * @export
		 */
		var SavedSearchApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * Creates a new saved search.
		         * @summary Create a saved search
		         * @param {CreateSavedSearchRequest} createSavedSearchRequest The saved search to persist.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createSavedSearch: function (createSavedSearchRequest, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'createSavedSearchRequest' is not null or undefined
		                            (0, common_1.assertParamExists)('createSavedSearch', 'createSavedSearchRequest', createSavedSearchRequest);
		                            localVarPath = "/saved-searches";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(createSavedSearchRequest, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Deletes the specified saved search.
		         * @summary Delete document by ID
		         * @param {string} id ID of the requested document.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteSavedSearch: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('deleteSavedSearch', 'id', id);
		                            localVarPath = "/saved-searches/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'DELETE' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Executes the specified saved search.
		         * @summary Execute a saved search by ID
		         * @param {string} id ID of the requested document.
		         * @param {SearchArguments} searchArguments When saved search execution is triggered by a scheduled search, *scheduleId* will specify the ID of the triggering scheduled search.  If *scheduleId* is not specified (when execution is triggered by a UI test), the *owner* and *recipients* arguments must be provided.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        executeSavedSearch: function (id, searchArguments, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('executeSavedSearch', 'id', id);
		                            // verify required parameter 'searchArguments' is not null or undefined
		                            (0, common_1.assertParamExists)('executeSavedSearch', 'searchArguments', searchArguments);
		                            localVarPath = "/saved-searches/{id}/execute"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(searchArguments, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Returns the specified saved search.
		         * @summary Return saved search by ID
		         * @param {string} id ID of the requested document.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getSavedSearch: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getSavedSearch', 'id', id);
		                            localVarPath = "/saved-searches/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Returns a list of saved searches.
		         * @summary A list of Saved Searches
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **owner.id**: *eq*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listSavedSearches: function (offset, limit, count, filters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/saved-searches";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Updates an existing saved search.   >**NOTE: You cannot update the `owner` of the saved search.**
		         * @summary Updates an existing saved search
		         * @param {string} id ID of the requested document.
		         * @param {SavedSearch} savedSearch The saved search to persist.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putSavedSearch: function (id, savedSearch, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('putSavedSearch', 'id', id);
		                            // verify required parameter 'savedSearch' is not null or undefined
		                            (0, common_1.assertParamExists)('putSavedSearch', 'savedSearch', savedSearch);
		                            localVarPath = "/saved-searches/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PUT' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(savedSearch, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.SavedSearchApiAxiosParamCreator = SavedSearchApiAxiosParamCreator;
		/**
		 * SavedSearchApi - functional programming interface
		 * @export
		 */
		var SavedSearchApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.SavedSearchApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * Creates a new saved search.
		         * @summary Create a saved search
		         * @param {CreateSavedSearchRequest} createSavedSearchRequest The saved search to persist.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createSavedSearch: function (createSavedSearchRequest, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.createSavedSearch(createSavedSearchRequest, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Deletes the specified saved search.
		         * @summary Delete document by ID
		         * @param {string} id ID of the requested document.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteSavedSearch: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.deleteSavedSearch(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Executes the specified saved search.
		         * @summary Execute a saved search by ID
		         * @param {string} id ID of the requested document.
		         * @param {SearchArguments} searchArguments When saved search execution is triggered by a scheduled search, *scheduleId* will specify the ID of the triggering scheduled search.  If *scheduleId* is not specified (when execution is triggered by a UI test), the *owner* and *recipients* arguments must be provided.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        executeSavedSearch: function (id, searchArguments, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.executeSavedSearch(id, searchArguments, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Returns the specified saved search.
		         * @summary Return saved search by ID
		         * @param {string} id ID of the requested document.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getSavedSearch: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getSavedSearch(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Returns a list of saved searches.
		         * @summary A list of Saved Searches
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **owner.id**: *eq*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listSavedSearches: function (offset, limit, count, filters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listSavedSearches(offset, limit, count, filters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Updates an existing saved search.   >**NOTE: You cannot update the `owner` of the saved search.**
		         * @summary Updates an existing saved search
		         * @param {string} id ID of the requested document.
		         * @param {SavedSearch} savedSearch The saved search to persist.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putSavedSearch: function (id, savedSearch, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.putSavedSearch(id, savedSearch, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.SavedSearchApiFp = SavedSearchApiFp;
		/**
		 * SavedSearchApi - factory interface
		 * @export
		 */
		var SavedSearchApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.SavedSearchApiFp)(configuration);
		    return {
		        /**
		         * Creates a new saved search.
		         * @summary Create a saved search
		         * @param {CreateSavedSearchRequest} createSavedSearchRequest The saved search to persist.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createSavedSearch: function (createSavedSearchRequest, axiosOptions) {
		            return localVarFp.createSavedSearch(createSavedSearchRequest, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Deletes the specified saved search.
		         * @summary Delete document by ID
		         * @param {string} id ID of the requested document.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteSavedSearch: function (id, axiosOptions) {
		            return localVarFp.deleteSavedSearch(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Executes the specified saved search.
		         * @summary Execute a saved search by ID
		         * @param {string} id ID of the requested document.
		         * @param {SearchArguments} searchArguments When saved search execution is triggered by a scheduled search, *scheduleId* will specify the ID of the triggering scheduled search.  If *scheduleId* is not specified (when execution is triggered by a UI test), the *owner* and *recipients* arguments must be provided.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        executeSavedSearch: function (id, searchArguments, axiosOptions) {
		            return localVarFp.executeSavedSearch(id, searchArguments, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Returns the specified saved search.
		         * @summary Return saved search by ID
		         * @param {string} id ID of the requested document.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getSavedSearch: function (id, axiosOptions) {
		            return localVarFp.getSavedSearch(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Returns a list of saved searches.
		         * @summary A list of Saved Searches
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **owner.id**: *eq*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listSavedSearches: function (offset, limit, count, filters, axiosOptions) {
		            return localVarFp.listSavedSearches(offset, limit, count, filters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Updates an existing saved search.   >**NOTE: You cannot update the `owner` of the saved search.**
		         * @summary Updates an existing saved search
		         * @param {string} id ID of the requested document.
		         * @param {SavedSearch} savedSearch The saved search to persist.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putSavedSearch: function (id, savedSearch, axiosOptions) {
		            return localVarFp.putSavedSearch(id, savedSearch, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.SavedSearchApiFactory = SavedSearchApiFactory;
		/**
		 * SavedSearchApi - object-oriented interface
		 * @export
		 * @class SavedSearchApi
		 * @extends {BaseAPI}
		 */
		var SavedSearchApi = /** @class */ (function (_super) {
		    __extends(SavedSearchApi, _super);
		    function SavedSearchApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * Creates a new saved search.
		     * @summary Create a saved search
		     * @param {SavedSearchApiCreateSavedSearchRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SavedSearchApi
		     */
		    SavedSearchApi.prototype.createSavedSearch = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SavedSearchApiFp)(this.configuration).createSavedSearch(requestParameters.createSavedSearchRequest, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Deletes the specified saved search.
		     * @summary Delete document by ID
		     * @param {SavedSearchApiDeleteSavedSearchRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SavedSearchApi
		     */
		    SavedSearchApi.prototype.deleteSavedSearch = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SavedSearchApiFp)(this.configuration).deleteSavedSearch(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Executes the specified saved search.
		     * @summary Execute a saved search by ID
		     * @param {SavedSearchApiExecuteSavedSearchRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SavedSearchApi
		     */
		    SavedSearchApi.prototype.executeSavedSearch = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SavedSearchApiFp)(this.configuration).executeSavedSearch(requestParameters.id, requestParameters.searchArguments, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Returns the specified saved search.
		     * @summary Return saved search by ID
		     * @param {SavedSearchApiGetSavedSearchRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SavedSearchApi
		     */
		    SavedSearchApi.prototype.getSavedSearch = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SavedSearchApiFp)(this.configuration).getSavedSearch(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Returns a list of saved searches.
		     * @summary A list of Saved Searches
		     * @param {SavedSearchApiListSavedSearchesRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SavedSearchApi
		     */
		    SavedSearchApi.prototype.listSavedSearches = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.SavedSearchApiFp)(this.configuration).listSavedSearches(requestParameters.offset, requestParameters.limit, requestParameters.count, requestParameters.filters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Updates an existing saved search.   >**NOTE: You cannot update the `owner` of the saved search.**
		     * @summary Updates an existing saved search
		     * @param {SavedSearchApiPutSavedSearchRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SavedSearchApi
		     */
		    SavedSearchApi.prototype.putSavedSearch = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SavedSearchApiFp)(this.configuration).putSavedSearch(requestParameters.id, requestParameters.savedSearch, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return SavedSearchApi;
		}(base_1.BaseAPI));
		exports.SavedSearchApi = SavedSearchApi;
		/**
		 * ScheduledSearchApi - axios parameter creator
		 * @export
		 */
		var ScheduledSearchApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * Creates a new scheduled search.
		         * @summary Create a new scheduled search
		         * @param {CreateScheduledSearchRequest} createScheduledSearchRequest The scheduled search to persist.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createScheduledSearch: function (createScheduledSearchRequest, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'createScheduledSearchRequest' is not null or undefined
		                            (0, common_1.assertParamExists)('createScheduledSearch', 'createScheduledSearchRequest', createScheduledSearchRequest);
		                            localVarPath = "/scheduled-searches";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(createScheduledSearchRequest, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Deletes the specified scheduled search.
		         * @summary Delete a Scheduled Search
		         * @param {string} id ID of the requested document.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteScheduledSearch: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('deleteScheduledSearch', 'id', id);
		                            localVarPath = "/scheduled-searches/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'DELETE' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Returns the specified scheduled search.
		         * @summary Get a Scheduled Search
		         * @param {string} id ID of the requested document.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getScheduledSearch: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getScheduledSearch', 'id', id);
		                            localVarPath = "/scheduled-searches/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Returns a list of scheduled searches.
		         * @summary List scheduled searches
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **owner.id**: *eq*  **savedSearchId**: *eq*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listScheduledSearch: function (offset, limit, count, filters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/scheduled-searches";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Unsubscribes a recipient from the specified scheduled search.
		         * @summary Unsubscribe a recipient from Scheduled Search
		         * @param {string} id ID of the requested document.
		         * @param {TypedReference} typedReference The recipient to be removed from the scheduled search.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        unsubscribeScheduledSearch: function (id, typedReference, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('unsubscribeScheduledSearch', 'id', id);
		                            // verify required parameter 'typedReference' is not null or undefined
		                            (0, common_1.assertParamExists)('unsubscribeScheduledSearch', 'typedReference', typedReference);
		                            localVarPath = "/scheduled-searches/{id}/unsubscribe"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(typedReference, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Updates an existing scheduled search.
		         * @summary Update an existing Scheduled Search
		         * @param {string} id ID of the requested document.
		         * @param {ScheduledSearch} scheduledSearch The scheduled search to persist.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateScheduledSearch: function (id, scheduledSearch, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('updateScheduledSearch', 'id', id);
		                            // verify required parameter 'scheduledSearch' is not null or undefined
		                            (0, common_1.assertParamExists)('updateScheduledSearch', 'scheduledSearch', scheduledSearch);
		                            localVarPath = "/scheduled-searches/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PUT' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(scheduledSearch, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.ScheduledSearchApiAxiosParamCreator = ScheduledSearchApiAxiosParamCreator;
		/**
		 * ScheduledSearchApi - functional programming interface
		 * @export
		 */
		var ScheduledSearchApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.ScheduledSearchApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * Creates a new scheduled search.
		         * @summary Create a new scheduled search
		         * @param {CreateScheduledSearchRequest} createScheduledSearchRequest The scheduled search to persist.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createScheduledSearch: function (createScheduledSearchRequest, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.createScheduledSearch(createScheduledSearchRequest, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Deletes the specified scheduled search.
		         * @summary Delete a Scheduled Search
		         * @param {string} id ID of the requested document.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteScheduledSearch: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.deleteScheduledSearch(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Returns the specified scheduled search.
		         * @summary Get a Scheduled Search
		         * @param {string} id ID of the requested document.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getScheduledSearch: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getScheduledSearch(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Returns a list of scheduled searches.
		         * @summary List scheduled searches
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **owner.id**: *eq*  **savedSearchId**: *eq*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listScheduledSearch: function (offset, limit, count, filters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listScheduledSearch(offset, limit, count, filters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Unsubscribes a recipient from the specified scheduled search.
		         * @summary Unsubscribe a recipient from Scheduled Search
		         * @param {string} id ID of the requested document.
		         * @param {TypedReference} typedReference The recipient to be removed from the scheduled search.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        unsubscribeScheduledSearch: function (id, typedReference, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.unsubscribeScheduledSearch(id, typedReference, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Updates an existing scheduled search.
		         * @summary Update an existing Scheduled Search
		         * @param {string} id ID of the requested document.
		         * @param {ScheduledSearch} scheduledSearch The scheduled search to persist.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateScheduledSearch: function (id, scheduledSearch, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.updateScheduledSearch(id, scheduledSearch, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.ScheduledSearchApiFp = ScheduledSearchApiFp;
		/**
		 * ScheduledSearchApi - factory interface
		 * @export
		 */
		var ScheduledSearchApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.ScheduledSearchApiFp)(configuration);
		    return {
		        /**
		         * Creates a new scheduled search.
		         * @summary Create a new scheduled search
		         * @param {CreateScheduledSearchRequest} createScheduledSearchRequest The scheduled search to persist.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createScheduledSearch: function (createScheduledSearchRequest, axiosOptions) {
		            return localVarFp.createScheduledSearch(createScheduledSearchRequest, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Deletes the specified scheduled search.
		         * @summary Delete a Scheduled Search
		         * @param {string} id ID of the requested document.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteScheduledSearch: function (id, axiosOptions) {
		            return localVarFp.deleteScheduledSearch(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Returns the specified scheduled search.
		         * @summary Get a Scheduled Search
		         * @param {string} id ID of the requested document.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getScheduledSearch: function (id, axiosOptions) {
		            return localVarFp.getScheduledSearch(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Returns a list of scheduled searches.
		         * @summary List scheduled searches
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **owner.id**: *eq*  **savedSearchId**: *eq*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listScheduledSearch: function (offset, limit, count, filters, axiosOptions) {
		            return localVarFp.listScheduledSearch(offset, limit, count, filters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Unsubscribes a recipient from the specified scheduled search.
		         * @summary Unsubscribe a recipient from Scheduled Search
		         * @param {string} id ID of the requested document.
		         * @param {TypedReference} typedReference The recipient to be removed from the scheduled search.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        unsubscribeScheduledSearch: function (id, typedReference, axiosOptions) {
		            return localVarFp.unsubscribeScheduledSearch(id, typedReference, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Updates an existing scheduled search.
		         * @summary Update an existing Scheduled Search
		         * @param {string} id ID of the requested document.
		         * @param {ScheduledSearch} scheduledSearch The scheduled search to persist.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateScheduledSearch: function (id, scheduledSearch, axiosOptions) {
		            return localVarFp.updateScheduledSearch(id, scheduledSearch, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.ScheduledSearchApiFactory = ScheduledSearchApiFactory;
		/**
		 * ScheduledSearchApi - object-oriented interface
		 * @export
		 * @class ScheduledSearchApi
		 * @extends {BaseAPI}
		 */
		var ScheduledSearchApi = /** @class */ (function (_super) {
		    __extends(ScheduledSearchApi, _super);
		    function ScheduledSearchApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * Creates a new scheduled search.
		     * @summary Create a new scheduled search
		     * @param {ScheduledSearchApiCreateScheduledSearchRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof ScheduledSearchApi
		     */
		    ScheduledSearchApi.prototype.createScheduledSearch = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.ScheduledSearchApiFp)(this.configuration).createScheduledSearch(requestParameters.createScheduledSearchRequest, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Deletes the specified scheduled search.
		     * @summary Delete a Scheduled Search
		     * @param {ScheduledSearchApiDeleteScheduledSearchRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof ScheduledSearchApi
		     */
		    ScheduledSearchApi.prototype.deleteScheduledSearch = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.ScheduledSearchApiFp)(this.configuration).deleteScheduledSearch(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Returns the specified scheduled search.
		     * @summary Get a Scheduled Search
		     * @param {ScheduledSearchApiGetScheduledSearchRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof ScheduledSearchApi
		     */
		    ScheduledSearchApi.prototype.getScheduledSearch = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.ScheduledSearchApiFp)(this.configuration).getScheduledSearch(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Returns a list of scheduled searches.
		     * @summary List scheduled searches
		     * @param {ScheduledSearchApiListScheduledSearchRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof ScheduledSearchApi
		     */
		    ScheduledSearchApi.prototype.listScheduledSearch = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.ScheduledSearchApiFp)(this.configuration).listScheduledSearch(requestParameters.offset, requestParameters.limit, requestParameters.count, requestParameters.filters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Unsubscribes a recipient from the specified scheduled search.
		     * @summary Unsubscribe a recipient from Scheduled Search
		     * @param {ScheduledSearchApiUnsubscribeScheduledSearchRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof ScheduledSearchApi
		     */
		    ScheduledSearchApi.prototype.unsubscribeScheduledSearch = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.ScheduledSearchApiFp)(this.configuration).unsubscribeScheduledSearch(requestParameters.id, requestParameters.typedReference, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Updates an existing scheduled search.
		     * @summary Update an existing Scheduled Search
		     * @param {ScheduledSearchApiUpdateScheduledSearchRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof ScheduledSearchApi
		     */
		    ScheduledSearchApi.prototype.updateScheduledSearch = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.ScheduledSearchApiFp)(this.configuration).updateScheduledSearch(requestParameters.id, requestParameters.scheduledSearch, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return ScheduledSearchApi;
		}(base_1.BaseAPI));
		exports.ScheduledSearchApi = ScheduledSearchApi;
		/**
		 * SearchApi - axios parameter creator
		 * @export
		 */
		var SearchApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * Performs a search query aggregation and returns the aggregation result. By default, you can page a maximum of 10,000 search result records.  To page past 10,000 records, you can use searchAfter paging.  Refer to [Paginating Search Queries](https://developer.sailpoint.com/idn/api/standard-collection-parameters#paginating-search-queries) for more information about how to implement searchAfter paging.
		         * @summary Perform a Search Query Aggregation
		         * @param {Search} search
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        searchAggregate: function (search, offset, limit, count, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'search' is not null or undefined
		                            (0, common_1.assertParamExists)('searchAggregate', 'search', search);
		                            localVarPath = "/search/aggregate";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(search, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Performs a search with a provided query and returns the count of results in the X-Total-Count header.
		         * @summary Count Documents Satisfying a Query
		         * @param {Search} search
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        searchCount: function (search, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'search' is not null or undefined
		                            (0, common_1.assertParamExists)('searchCount', 'search', search);
		                            localVarPath = "/search/count";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(search, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Fetches a single document from the specified index, using the specified document ID.
		         * @summary Get a Document by ID
		         * @param {string} index The index from which to fetch the specified document.  The currently supported index names are: *accessprofiles*, *accountactivities*, *entitlements*, *events*, *identities*, and *roles*.
		         * @param {string} id ID of the requested document.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        searchGet: function (index, id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'index' is not null or undefined
		                            (0, common_1.assertParamExists)('searchGet', 'index', index);
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('searchGet', 'id', id);
		                            localVarPath = "/search/{index}/{id}"
		                                .replace("{".concat("index", "}"), encodeURIComponent(String(index)))
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Performs a search with the provided query and returns a matching result collection. By default, you can page a maximum of 10,000 search result records.  To page past 10,000 records, you can use searchAfter paging.  Refer to [Paginating Search Queries](https://developer.sailpoint.com/idn/api/standard-collection-parameters#paginating-search-queries) for more information about how to implement searchAfter paging.
		         * @summary Perform Search
		         * @param {Search} search
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        searchPost: function (search, offset, limit, count, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'search' is not null or undefined
		                            (0, common_1.assertParamExists)('searchPost', 'search', search);
		                            localVarPath = "/search";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(search, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.SearchApiAxiosParamCreator = SearchApiAxiosParamCreator;
		/**
		 * SearchApi - functional programming interface
		 * @export
		 */
		var SearchApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.SearchApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * Performs a search query aggregation and returns the aggregation result. By default, you can page a maximum of 10,000 search result records.  To page past 10,000 records, you can use searchAfter paging.  Refer to [Paginating Search Queries](https://developer.sailpoint.com/idn/api/standard-collection-parameters#paginating-search-queries) for more information about how to implement searchAfter paging.
		         * @summary Perform a Search Query Aggregation
		         * @param {Search} search
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        searchAggregate: function (search, offset, limit, count, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.searchAggregate(search, offset, limit, count, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Performs a search with a provided query and returns the count of results in the X-Total-Count header.
		         * @summary Count Documents Satisfying a Query
		         * @param {Search} search
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        searchCount: function (search, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.searchCount(search, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Fetches a single document from the specified index, using the specified document ID.
		         * @summary Get a Document by ID
		         * @param {string} index The index from which to fetch the specified document.  The currently supported index names are: *accessprofiles*, *accountactivities*, *entitlements*, *events*, *identities*, and *roles*.
		         * @param {string} id ID of the requested document.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        searchGet: function (index, id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.searchGet(index, id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Performs a search with the provided query and returns a matching result collection. By default, you can page a maximum of 10,000 search result records.  To page past 10,000 records, you can use searchAfter paging.  Refer to [Paginating Search Queries](https://developer.sailpoint.com/idn/api/standard-collection-parameters#paginating-search-queries) for more information about how to implement searchAfter paging.
		         * @summary Perform Search
		         * @param {Search} search
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        searchPost: function (search, offset, limit, count, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.searchPost(search, offset, limit, count, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.SearchApiFp = SearchApiFp;
		/**
		 * SearchApi - factory interface
		 * @export
		 */
		var SearchApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.SearchApiFp)(configuration);
		    return {
		        /**
		         * Performs a search query aggregation and returns the aggregation result. By default, you can page a maximum of 10,000 search result records.  To page past 10,000 records, you can use searchAfter paging.  Refer to [Paginating Search Queries](https://developer.sailpoint.com/idn/api/standard-collection-parameters#paginating-search-queries) for more information about how to implement searchAfter paging.
		         * @summary Perform a Search Query Aggregation
		         * @param {Search} search
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        searchAggregate: function (search, offset, limit, count, axiosOptions) {
		            return localVarFp.searchAggregate(search, offset, limit, count, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Performs a search with a provided query and returns the count of results in the X-Total-Count header.
		         * @summary Count Documents Satisfying a Query
		         * @param {Search} search
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        searchCount: function (search, axiosOptions) {
		            return localVarFp.searchCount(search, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Fetches a single document from the specified index, using the specified document ID.
		         * @summary Get a Document by ID
		         * @param {string} index The index from which to fetch the specified document.  The currently supported index names are: *accessprofiles*, *accountactivities*, *entitlements*, *events*, *identities*, and *roles*.
		         * @param {string} id ID of the requested document.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        searchGet: function (index, id, axiosOptions) {
		            return localVarFp.searchGet(index, id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Performs a search with the provided query and returns a matching result collection. By default, you can page a maximum of 10,000 search result records.  To page past 10,000 records, you can use searchAfter paging.  Refer to [Paginating Search Queries](https://developer.sailpoint.com/idn/api/standard-collection-parameters#paginating-search-queries) for more information about how to implement searchAfter paging.
		         * @summary Perform Search
		         * @param {Search} search
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        searchPost: function (search, offset, limit, count, axiosOptions) {
		            return localVarFp.searchPost(search, offset, limit, count, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.SearchApiFactory = SearchApiFactory;
		/**
		 * SearchApi - object-oriented interface
		 * @export
		 * @class SearchApi
		 * @extends {BaseAPI}
		 */
		var SearchApi = /** @class */ (function (_super) {
		    __extends(SearchApi, _super);
		    function SearchApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * Performs a search query aggregation and returns the aggregation result. By default, you can page a maximum of 10,000 search result records.  To page past 10,000 records, you can use searchAfter paging.  Refer to [Paginating Search Queries](https://developer.sailpoint.com/idn/api/standard-collection-parameters#paginating-search-queries) for more information about how to implement searchAfter paging.
		     * @summary Perform a Search Query Aggregation
		     * @param {SearchApiSearchAggregateRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SearchApi
		     */
		    SearchApi.prototype.searchAggregate = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SearchApiFp)(this.configuration).searchAggregate(requestParameters.search, requestParameters.offset, requestParameters.limit, requestParameters.count, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Performs a search with a provided query and returns the count of results in the X-Total-Count header.
		     * @summary Count Documents Satisfying a Query
		     * @param {SearchApiSearchCountRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SearchApi
		     */
		    SearchApi.prototype.searchCount = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SearchApiFp)(this.configuration).searchCount(requestParameters.search, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Fetches a single document from the specified index, using the specified document ID.
		     * @summary Get a Document by ID
		     * @param {SearchApiSearchGetRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SearchApi
		     */
		    SearchApi.prototype.searchGet = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SearchApiFp)(this.configuration).searchGet(requestParameters.index, requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Performs a search with the provided query and returns a matching result collection. By default, you can page a maximum of 10,000 search result records.  To page past 10,000 records, you can use searchAfter paging.  Refer to [Paginating Search Queries](https://developer.sailpoint.com/idn/api/standard-collection-parameters#paginating-search-queries) for more information about how to implement searchAfter paging.
		     * @summary Perform Search
		     * @param {SearchApiSearchPostRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SearchApi
		     */
		    SearchApi.prototype.searchPost = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SearchApiFp)(this.configuration).searchPost(requestParameters.search, requestParameters.offset, requestParameters.limit, requestParameters.count, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return SearchApi;
		}(base_1.BaseAPI));
		exports.SearchApi = SearchApi;
		/**
		 * SegmentsApi - axios parameter creator
		 * @export
		 */
		var SegmentsApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * This API creates a segment.  >**Note:** Segment definitions may take time to propagate to all identities. A token with ORG_ADMIN or API authority is required to call this API.
		         * @summary Create Segment
		         * @param {Segment} segment
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createSegment: function (segment, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'segment' is not null or undefined
		                            (0, common_1.assertParamExists)('createSegment', 'segment', segment);
		                            localVarPath = "/segments";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(segment, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API deletes the segment specified by the given ID. >**Note:** that segment deletion may take some time to become effective. A token with ORG_ADMIN or API authority is required to call this API.
		         * @summary Delete Segment by ID
		         * @param {string} id The segment ID to delete.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteSegment: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('deleteSegment', 'id', id);
		                            localVarPath = "/segments/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'DELETE' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns the segment specified by the given ID. A token with ORG_ADMIN or API authority is required to call this API.
		         * @summary Get Segment by ID
		         * @param {string} id The segment ID to retrieve.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getSegment: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getSegment', 'id', id);
		                            localVarPath = "/segments/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns a list of all segments.  A token with ORG_ADMIN or API authority is required to call this API.
		         * @summary List Segments
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listSegments: function (limit, offset, count, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/segments";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Use this API to update segment fields by using the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard. >**Note:** Changes to a segment may take some time to propagate to all identities. A token with ORG_ADMIN or API authority is required to call this API.
		         * @summary Update Segment
		         * @param {string} id The segment ID to modify.
		         * @param {Array<object>} requestBody A list of segment update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.  The following fields are patchable: * name * description * owner * visibilityCriteria * active
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchSegment: function (id, requestBody, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('patchSegment', 'id', id);
		                            // verify required parameter 'requestBody' is not null or undefined
		                            (0, common_1.assertParamExists)('patchSegment', 'requestBody', requestBody);
		                            localVarPath = "/segments/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PATCH' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json-patch+json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(requestBody, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.SegmentsApiAxiosParamCreator = SegmentsApiAxiosParamCreator;
		/**
		 * SegmentsApi - functional programming interface
		 * @export
		 */
		var SegmentsApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.SegmentsApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * This API creates a segment.  >**Note:** Segment definitions may take time to propagate to all identities. A token with ORG_ADMIN or API authority is required to call this API.
		         * @summary Create Segment
		         * @param {Segment} segment
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createSegment: function (segment, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.createSegment(segment, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API deletes the segment specified by the given ID. >**Note:** that segment deletion may take some time to become effective. A token with ORG_ADMIN or API authority is required to call this API.
		         * @summary Delete Segment by ID
		         * @param {string} id The segment ID to delete.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteSegment: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.deleteSegment(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns the segment specified by the given ID. A token with ORG_ADMIN or API authority is required to call this API.
		         * @summary Get Segment by ID
		         * @param {string} id The segment ID to retrieve.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getSegment: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getSegment(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns a list of all segments.  A token with ORG_ADMIN or API authority is required to call this API.
		         * @summary List Segments
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listSegments: function (limit, offset, count, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listSegments(limit, offset, count, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Use this API to update segment fields by using the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard. >**Note:** Changes to a segment may take some time to propagate to all identities. A token with ORG_ADMIN or API authority is required to call this API.
		         * @summary Update Segment
		         * @param {string} id The segment ID to modify.
		         * @param {Array<object>} requestBody A list of segment update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.  The following fields are patchable: * name * description * owner * visibilityCriteria * active
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchSegment: function (id, requestBody, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.patchSegment(id, requestBody, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.SegmentsApiFp = SegmentsApiFp;
		/**
		 * SegmentsApi - factory interface
		 * @export
		 */
		var SegmentsApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.SegmentsApiFp)(configuration);
		    return {
		        /**
		         * This API creates a segment.  >**Note:** Segment definitions may take time to propagate to all identities. A token with ORG_ADMIN or API authority is required to call this API.
		         * @summary Create Segment
		         * @param {Segment} segment
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createSegment: function (segment, axiosOptions) {
		            return localVarFp.createSegment(segment, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API deletes the segment specified by the given ID. >**Note:** that segment deletion may take some time to become effective. A token with ORG_ADMIN or API authority is required to call this API.
		         * @summary Delete Segment by ID
		         * @param {string} id The segment ID to delete.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteSegment: function (id, axiosOptions) {
		            return localVarFp.deleteSegment(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API returns the segment specified by the given ID. A token with ORG_ADMIN or API authority is required to call this API.
		         * @summary Get Segment by ID
		         * @param {string} id The segment ID to retrieve.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getSegment: function (id, axiosOptions) {
		            return localVarFp.getSegment(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API returns a list of all segments.  A token with ORG_ADMIN or API authority is required to call this API.
		         * @summary List Segments
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listSegments: function (limit, offset, count, axiosOptions) {
		            return localVarFp.listSegments(limit, offset, count, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Use this API to update segment fields by using the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard. >**Note:** Changes to a segment may take some time to propagate to all identities. A token with ORG_ADMIN or API authority is required to call this API.
		         * @summary Update Segment
		         * @param {string} id The segment ID to modify.
		         * @param {Array<object>} requestBody A list of segment update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.  The following fields are patchable: * name * description * owner * visibilityCriteria * active
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchSegment: function (id, requestBody, axiosOptions) {
		            return localVarFp.patchSegment(id, requestBody, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.SegmentsApiFactory = SegmentsApiFactory;
		/**
		 * SegmentsApi - object-oriented interface
		 * @export
		 * @class SegmentsApi
		 * @extends {BaseAPI}
		 */
		var SegmentsApi = /** @class */ (function (_super) {
		    __extends(SegmentsApi, _super);
		    function SegmentsApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * This API creates a segment.  >**Note:** Segment definitions may take time to propagate to all identities. A token with ORG_ADMIN or API authority is required to call this API.
		     * @summary Create Segment
		     * @param {SegmentsApiCreateSegmentRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SegmentsApi
		     */
		    SegmentsApi.prototype.createSegment = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SegmentsApiFp)(this.configuration).createSegment(requestParameters.segment, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API deletes the segment specified by the given ID. >**Note:** that segment deletion may take some time to become effective. A token with ORG_ADMIN or API authority is required to call this API.
		     * @summary Delete Segment by ID
		     * @param {SegmentsApiDeleteSegmentRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SegmentsApi
		     */
		    SegmentsApi.prototype.deleteSegment = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SegmentsApiFp)(this.configuration).deleteSegment(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API returns the segment specified by the given ID. A token with ORG_ADMIN or API authority is required to call this API.
		     * @summary Get Segment by ID
		     * @param {SegmentsApiGetSegmentRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SegmentsApi
		     */
		    SegmentsApi.prototype.getSegment = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SegmentsApiFp)(this.configuration).getSegment(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API returns a list of all segments.  A token with ORG_ADMIN or API authority is required to call this API.
		     * @summary List Segments
		     * @param {SegmentsApiListSegmentsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SegmentsApi
		     */
		    SegmentsApi.prototype.listSegments = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.SegmentsApiFp)(this.configuration).listSegments(requestParameters.limit, requestParameters.offset, requestParameters.count, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Use this API to update segment fields by using the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard. >**Note:** Changes to a segment may take some time to propagate to all identities. A token with ORG_ADMIN or API authority is required to call this API.
		     * @summary Update Segment
		     * @param {SegmentsApiPatchSegmentRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SegmentsApi
		     */
		    SegmentsApi.prototype.patchSegment = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SegmentsApiFp)(this.configuration).patchSegment(requestParameters.id, requestParameters.requestBody, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return SegmentsApi;
		}(base_1.BaseAPI));
		exports.SegmentsApi = SegmentsApi;
		/**
		 * ServiceDeskIntegrationApi - axios parameter creator
		 * @export
		 */
		var ServiceDeskIntegrationApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * Create a new Service Desk Integrations.  A token with Org Admin or Service Desk Admin authority is required to access this endpoint.
		         * @summary Create new Service Desk integration
		         * @param {ServiceDeskIntegrationDto} serviceDeskIntegrationDto The specifics of a new integration to create
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createServiceDeskIntegration: function (serviceDeskIntegrationDto, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'serviceDeskIntegrationDto' is not null or undefined
		                            (0, common_1.assertParamExists)('createServiceDeskIntegration', 'serviceDeskIntegrationDto', serviceDeskIntegrationDto);
		                            localVarPath = "/service-desk-integrations";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(serviceDeskIntegrationDto, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Delete an existing Service Desk integration by ID.  A token with Org Admin or Service Desk Admin authority is required to access this endpoint.
		         * @summary Delete a Service Desk integration
		         * @param {string} id ID of Service Desk integration to delete
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteServiceDeskIntegration: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('deleteServiceDeskIntegration', 'id', id);
		                            localVarPath = "/service-desk-integrations/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'DELETE' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Get an existing Service Desk integration by ID.  A token with Org Admin or Service Desk Admin authority is required to access this endpoint.
		         * @summary Get a Service Desk integration
		         * @param {string} id ID of the Service Desk integration to get
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getServiceDeskIntegration: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getServiceDeskIntegration', 'id', id);
		                            localVarPath = "/service-desk-integrations/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API endpoint returns an existing Service Desk integration template by scriptName.  A token with Org Admin or Service Desk Admin authority is required to access this endpoint.
		         * @summary Service Desk integration template by scriptName.
		         * @param {string} scriptName The scriptName value of the Service Desk integration template to get
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getServiceDeskIntegrationTemplate: function (scriptName, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'scriptName' is not null or undefined
		                            (0, common_1.assertParamExists)('getServiceDeskIntegrationTemplate', 'scriptName', scriptName);
		                            localVarPath = "/service-desk-integrations/templates/{scriptName}"
		                                .replace("{".concat("scriptName", "}"), encodeURIComponent(String(scriptName)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API endpoint returns the current list of supported Service Desk integration types.  A token with Org Admin or Service Desk Admin authority is required to access this endpoint.
		         * @summary Service Desk Integration Types List.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getServiceDeskIntegrationTypes: function (axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/service-desk-integrations/types";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Get a list of ServiceDeskIntegrationDto for existing Service Desk Integrations.  A token with Org Admin or Service Desk Admin authority is required to access this endpoint.
		         * @summary List existing Service Desk Integrations
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name**
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **name**: *eq*  **type**: *eq, in*  **cluster**: *eq, in*
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getServiceDeskIntegrations: function (offset, limit, sorters, filters, count, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/service-desk-integrations";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Get the time check configuration of queued SDIM tickets.  A token with Org Admin or Service Desk Admin authority is required to access this endpoint.
		         * @summary Get the time check configuration
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getStatusCheckDetails: function (axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/service-desk-integrations/status-check-configuration";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Update an existing ServiceDeskIntegration by ID with a PATCH request.
		         * @summary Service Desk Integration Update PATCH
		         * @param {string} id ID of the Service Desk integration to update
		         * @param {PatchServiceDeskIntegrationRequest} patchServiceDeskIntegrationRequest A list of SDIM update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.  Only &#x60;replace&#x60; operations are accepted by this endpoint.  A 403 Forbidden Error indicates that you attempted to PATCH a operation that is not allowed.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchServiceDeskIntegration: function (id, patchServiceDeskIntegrationRequest, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('patchServiceDeskIntegration', 'id', id);
		                            // verify required parameter 'patchServiceDeskIntegrationRequest' is not null or undefined
		                            (0, common_1.assertParamExists)('patchServiceDeskIntegration', 'patchServiceDeskIntegrationRequest', patchServiceDeskIntegrationRequest);
		                            localVarPath = "/service-desk-integrations/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PATCH' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json-patch+json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(patchServiceDeskIntegrationRequest, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Update an existing Service Desk integration by ID with updated value in JSON form as the request body.  A token with Org Admin or Service Desk Admin authority is required to access this endpoint.
		         * @summary Update a Service Desk integration
		         * @param {string} id ID of the Service Desk integration to update
		         * @param {ServiceDeskIntegrationDto} serviceDeskIntegrationDto The specifics of the integration to update
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putServiceDeskIntegration: function (id, serviceDeskIntegrationDto, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('putServiceDeskIntegration', 'id', id);
		                            // verify required parameter 'serviceDeskIntegrationDto' is not null or undefined
		                            (0, common_1.assertParamExists)('putServiceDeskIntegration', 'serviceDeskIntegrationDto', serviceDeskIntegrationDto);
		                            localVarPath = "/service-desk-integrations/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PUT' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(serviceDeskIntegrationDto, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Update the time check configuration of queued SDIM tickets.  A token with Org Admin or Service Desk Admin authority is required to access this endpoint.
		         * @summary Update the time check configuration
		         * @param {QueuedCheckConfigDetails} queuedCheckConfigDetails the modified time check configuration
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateStatusCheckDetails: function (queuedCheckConfigDetails, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'queuedCheckConfigDetails' is not null or undefined
		                            (0, common_1.assertParamExists)('updateStatusCheckDetails', 'queuedCheckConfigDetails', queuedCheckConfigDetails);
		                            localVarPath = "/service-desk-integrations/status-check-configuration";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PUT' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(queuedCheckConfigDetails, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.ServiceDeskIntegrationApiAxiosParamCreator = ServiceDeskIntegrationApiAxiosParamCreator;
		/**
		 * ServiceDeskIntegrationApi - functional programming interface
		 * @export
		 */
		var ServiceDeskIntegrationApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.ServiceDeskIntegrationApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * Create a new Service Desk Integrations.  A token with Org Admin or Service Desk Admin authority is required to access this endpoint.
		         * @summary Create new Service Desk integration
		         * @param {ServiceDeskIntegrationDto} serviceDeskIntegrationDto The specifics of a new integration to create
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createServiceDeskIntegration: function (serviceDeskIntegrationDto, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.createServiceDeskIntegration(serviceDeskIntegrationDto, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Delete an existing Service Desk integration by ID.  A token with Org Admin or Service Desk Admin authority is required to access this endpoint.
		         * @summary Delete a Service Desk integration
		         * @param {string} id ID of Service Desk integration to delete
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteServiceDeskIntegration: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.deleteServiceDeskIntegration(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Get an existing Service Desk integration by ID.  A token with Org Admin or Service Desk Admin authority is required to access this endpoint.
		         * @summary Get a Service Desk integration
		         * @param {string} id ID of the Service Desk integration to get
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getServiceDeskIntegration: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getServiceDeskIntegration(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API endpoint returns an existing Service Desk integration template by scriptName.  A token with Org Admin or Service Desk Admin authority is required to access this endpoint.
		         * @summary Service Desk integration template by scriptName.
		         * @param {string} scriptName The scriptName value of the Service Desk integration template to get
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getServiceDeskIntegrationTemplate: function (scriptName, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getServiceDeskIntegrationTemplate(scriptName, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API endpoint returns the current list of supported Service Desk integration types.  A token with Org Admin or Service Desk Admin authority is required to access this endpoint.
		         * @summary Service Desk Integration Types List.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getServiceDeskIntegrationTypes: function (axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getServiceDeskIntegrationTypes(axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Get a list of ServiceDeskIntegrationDto for existing Service Desk Integrations.  A token with Org Admin or Service Desk Admin authority is required to access this endpoint.
		         * @summary List existing Service Desk Integrations
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name**
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **name**: *eq*  **type**: *eq, in*  **cluster**: *eq, in*
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getServiceDeskIntegrations: function (offset, limit, sorters, filters, count, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getServiceDeskIntegrations(offset, limit, sorters, filters, count, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Get the time check configuration of queued SDIM tickets.  A token with Org Admin or Service Desk Admin authority is required to access this endpoint.
		         * @summary Get the time check configuration
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getStatusCheckDetails: function (axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getStatusCheckDetails(axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Update an existing ServiceDeskIntegration by ID with a PATCH request.
		         * @summary Service Desk Integration Update PATCH
		         * @param {string} id ID of the Service Desk integration to update
		         * @param {PatchServiceDeskIntegrationRequest} patchServiceDeskIntegrationRequest A list of SDIM update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.  Only &#x60;replace&#x60; operations are accepted by this endpoint.  A 403 Forbidden Error indicates that you attempted to PATCH a operation that is not allowed.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchServiceDeskIntegration: function (id, patchServiceDeskIntegrationRequest, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.patchServiceDeskIntegration(id, patchServiceDeskIntegrationRequest, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Update an existing Service Desk integration by ID with updated value in JSON form as the request body.  A token with Org Admin or Service Desk Admin authority is required to access this endpoint.
		         * @summary Update a Service Desk integration
		         * @param {string} id ID of the Service Desk integration to update
		         * @param {ServiceDeskIntegrationDto} serviceDeskIntegrationDto The specifics of the integration to update
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putServiceDeskIntegration: function (id, serviceDeskIntegrationDto, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.putServiceDeskIntegration(id, serviceDeskIntegrationDto, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Update the time check configuration of queued SDIM tickets.  A token with Org Admin or Service Desk Admin authority is required to access this endpoint.
		         * @summary Update the time check configuration
		         * @param {QueuedCheckConfigDetails} queuedCheckConfigDetails the modified time check configuration
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateStatusCheckDetails: function (queuedCheckConfigDetails, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.updateStatusCheckDetails(queuedCheckConfigDetails, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.ServiceDeskIntegrationApiFp = ServiceDeskIntegrationApiFp;
		/**
		 * ServiceDeskIntegrationApi - factory interface
		 * @export
		 */
		var ServiceDeskIntegrationApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.ServiceDeskIntegrationApiFp)(configuration);
		    return {
		        /**
		         * Create a new Service Desk Integrations.  A token with Org Admin or Service Desk Admin authority is required to access this endpoint.
		         * @summary Create new Service Desk integration
		         * @param {ServiceDeskIntegrationDto} serviceDeskIntegrationDto The specifics of a new integration to create
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createServiceDeskIntegration: function (serviceDeskIntegrationDto, axiosOptions) {
		            return localVarFp.createServiceDeskIntegration(serviceDeskIntegrationDto, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Delete an existing Service Desk integration by ID.  A token with Org Admin or Service Desk Admin authority is required to access this endpoint.
		         * @summary Delete a Service Desk integration
		         * @param {string} id ID of Service Desk integration to delete
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteServiceDeskIntegration: function (id, axiosOptions) {
		            return localVarFp.deleteServiceDeskIntegration(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Get an existing Service Desk integration by ID.  A token with Org Admin or Service Desk Admin authority is required to access this endpoint.
		         * @summary Get a Service Desk integration
		         * @param {string} id ID of the Service Desk integration to get
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getServiceDeskIntegration: function (id, axiosOptions) {
		            return localVarFp.getServiceDeskIntegration(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API endpoint returns an existing Service Desk integration template by scriptName.  A token with Org Admin or Service Desk Admin authority is required to access this endpoint.
		         * @summary Service Desk integration template by scriptName.
		         * @param {string} scriptName The scriptName value of the Service Desk integration template to get
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getServiceDeskIntegrationTemplate: function (scriptName, axiosOptions) {
		            return localVarFp.getServiceDeskIntegrationTemplate(scriptName, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API endpoint returns the current list of supported Service Desk integration types.  A token with Org Admin or Service Desk Admin authority is required to access this endpoint.
		         * @summary Service Desk Integration Types List.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getServiceDeskIntegrationTypes: function (axiosOptions) {
		            return localVarFp.getServiceDeskIntegrationTypes(axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Get a list of ServiceDeskIntegrationDto for existing Service Desk Integrations.  A token with Org Admin or Service Desk Admin authority is required to access this endpoint.
		         * @summary List existing Service Desk Integrations
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **name**
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in*  **name**: *eq*  **type**: *eq, in*  **cluster**: *eq, in*
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getServiceDeskIntegrations: function (offset, limit, sorters, filters, count, axiosOptions) {
		            return localVarFp.getServiceDeskIntegrations(offset, limit, sorters, filters, count, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Get the time check configuration of queued SDIM tickets.  A token with Org Admin or Service Desk Admin authority is required to access this endpoint.
		         * @summary Get the time check configuration
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getStatusCheckDetails: function (axiosOptions) {
		            return localVarFp.getStatusCheckDetails(axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Update an existing ServiceDeskIntegration by ID with a PATCH request.
		         * @summary Service Desk Integration Update PATCH
		         * @param {string} id ID of the Service Desk integration to update
		         * @param {PatchServiceDeskIntegrationRequest} patchServiceDeskIntegrationRequest A list of SDIM update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.  Only &#x60;replace&#x60; operations are accepted by this endpoint.  A 403 Forbidden Error indicates that you attempted to PATCH a operation that is not allowed.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        patchServiceDeskIntegration: function (id, patchServiceDeskIntegrationRequest, axiosOptions) {
		            return localVarFp.patchServiceDeskIntegration(id, patchServiceDeskIntegrationRequest, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Update an existing Service Desk integration by ID with updated value in JSON form as the request body.  A token with Org Admin or Service Desk Admin authority is required to access this endpoint.
		         * @summary Update a Service Desk integration
		         * @param {string} id ID of the Service Desk integration to update
		         * @param {ServiceDeskIntegrationDto} serviceDeskIntegrationDto The specifics of the integration to update
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putServiceDeskIntegration: function (id, serviceDeskIntegrationDto, axiosOptions) {
		            return localVarFp.putServiceDeskIntegration(id, serviceDeskIntegrationDto, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Update the time check configuration of queued SDIM tickets.  A token with Org Admin or Service Desk Admin authority is required to access this endpoint.
		         * @summary Update the time check configuration
		         * @param {QueuedCheckConfigDetails} queuedCheckConfigDetails the modified time check configuration
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateStatusCheckDetails: function (queuedCheckConfigDetails, axiosOptions) {
		            return localVarFp.updateStatusCheckDetails(queuedCheckConfigDetails, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.ServiceDeskIntegrationApiFactory = ServiceDeskIntegrationApiFactory;
		/**
		 * ServiceDeskIntegrationApi - object-oriented interface
		 * @export
		 * @class ServiceDeskIntegrationApi
		 * @extends {BaseAPI}
		 */
		var ServiceDeskIntegrationApi = /** @class */ (function (_super) {
		    __extends(ServiceDeskIntegrationApi, _super);
		    function ServiceDeskIntegrationApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * Create a new Service Desk Integrations.  A token with Org Admin or Service Desk Admin authority is required to access this endpoint.
		     * @summary Create new Service Desk integration
		     * @param {ServiceDeskIntegrationApiCreateServiceDeskIntegrationRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof ServiceDeskIntegrationApi
		     */
		    ServiceDeskIntegrationApi.prototype.createServiceDeskIntegration = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.ServiceDeskIntegrationApiFp)(this.configuration).createServiceDeskIntegration(requestParameters.serviceDeskIntegrationDto, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Delete an existing Service Desk integration by ID.  A token with Org Admin or Service Desk Admin authority is required to access this endpoint.
		     * @summary Delete a Service Desk integration
		     * @param {ServiceDeskIntegrationApiDeleteServiceDeskIntegrationRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof ServiceDeskIntegrationApi
		     */
		    ServiceDeskIntegrationApi.prototype.deleteServiceDeskIntegration = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.ServiceDeskIntegrationApiFp)(this.configuration).deleteServiceDeskIntegration(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Get an existing Service Desk integration by ID.  A token with Org Admin or Service Desk Admin authority is required to access this endpoint.
		     * @summary Get a Service Desk integration
		     * @param {ServiceDeskIntegrationApiGetServiceDeskIntegrationRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof ServiceDeskIntegrationApi
		     */
		    ServiceDeskIntegrationApi.prototype.getServiceDeskIntegration = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.ServiceDeskIntegrationApiFp)(this.configuration).getServiceDeskIntegration(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API endpoint returns an existing Service Desk integration template by scriptName.  A token with Org Admin or Service Desk Admin authority is required to access this endpoint.
		     * @summary Service Desk integration template by scriptName.
		     * @param {ServiceDeskIntegrationApiGetServiceDeskIntegrationTemplateRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof ServiceDeskIntegrationApi
		     */
		    ServiceDeskIntegrationApi.prototype.getServiceDeskIntegrationTemplate = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.ServiceDeskIntegrationApiFp)(this.configuration).getServiceDeskIntegrationTemplate(requestParameters.scriptName, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API endpoint returns the current list of supported Service Desk integration types.  A token with Org Admin or Service Desk Admin authority is required to access this endpoint.
		     * @summary Service Desk Integration Types List.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof ServiceDeskIntegrationApi
		     */
		    ServiceDeskIntegrationApi.prototype.getServiceDeskIntegrationTypes = function (axiosOptions) {
		        var _this = this;
		        return (0, exports.ServiceDeskIntegrationApiFp)(this.configuration).getServiceDeskIntegrationTypes(axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Get a list of ServiceDeskIntegrationDto for existing Service Desk Integrations.  A token with Org Admin or Service Desk Admin authority is required to access this endpoint.
		     * @summary List existing Service Desk Integrations
		     * @param {ServiceDeskIntegrationApiGetServiceDeskIntegrationsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof ServiceDeskIntegrationApi
		     */
		    ServiceDeskIntegrationApi.prototype.getServiceDeskIntegrations = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.ServiceDeskIntegrationApiFp)(this.configuration).getServiceDeskIntegrations(requestParameters.offset, requestParameters.limit, requestParameters.sorters, requestParameters.filters, requestParameters.count, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Get the time check configuration of queued SDIM tickets.  A token with Org Admin or Service Desk Admin authority is required to access this endpoint.
		     * @summary Get the time check configuration
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof ServiceDeskIntegrationApi
		     */
		    ServiceDeskIntegrationApi.prototype.getStatusCheckDetails = function (axiosOptions) {
		        var _this = this;
		        return (0, exports.ServiceDeskIntegrationApiFp)(this.configuration).getStatusCheckDetails(axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Update an existing ServiceDeskIntegration by ID with a PATCH request.
		     * @summary Service Desk Integration Update PATCH
		     * @param {ServiceDeskIntegrationApiPatchServiceDeskIntegrationRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof ServiceDeskIntegrationApi
		     */
		    ServiceDeskIntegrationApi.prototype.patchServiceDeskIntegration = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.ServiceDeskIntegrationApiFp)(this.configuration).patchServiceDeskIntegration(requestParameters.id, requestParameters.patchServiceDeskIntegrationRequest, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Update an existing Service Desk integration by ID with updated value in JSON form as the request body.  A token with Org Admin or Service Desk Admin authority is required to access this endpoint.
		     * @summary Update a Service Desk integration
		     * @param {ServiceDeskIntegrationApiPutServiceDeskIntegrationRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof ServiceDeskIntegrationApi
		     */
		    ServiceDeskIntegrationApi.prototype.putServiceDeskIntegration = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.ServiceDeskIntegrationApiFp)(this.configuration).putServiceDeskIntegration(requestParameters.id, requestParameters.serviceDeskIntegrationDto, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Update the time check configuration of queued SDIM tickets.  A token with Org Admin or Service Desk Admin authority is required to access this endpoint.
		     * @summary Update the time check configuration
		     * @param {ServiceDeskIntegrationApiUpdateStatusCheckDetailsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof ServiceDeskIntegrationApi
		     */
		    ServiceDeskIntegrationApi.prototype.updateStatusCheckDetails = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.ServiceDeskIntegrationApiFp)(this.configuration).updateStatusCheckDetails(requestParameters.queuedCheckConfigDetails, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return ServiceDeskIntegrationApi;
		}(base_1.BaseAPI));
		exports.ServiceDeskIntegrationApi = ServiceDeskIntegrationApi;
		/**
		 * SourceUsagesApi - axios parameter creator
		 * @export
		 */
		var SourceUsagesApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * This API returns the status of the source usage insights setup by IDN source ID.
		         * @summary Finds status of source usage
		         * @param {string} sourceId ID of IDN source
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getStatusBySourceId: function (sourceId, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'sourceId' is not null or undefined
		                            (0, common_1.assertParamExists)('getStatusBySourceId', 'sourceId', sourceId);
		                            localVarPath = "/source-usages/{sourceId}/status"
		                                .replace("{".concat("sourceId", "}"), encodeURIComponent(String(sourceId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns a summary of source usage insights for past 12 months.
		         * @summary Returns source usage insights
		         * @param {string} sourceId ID of IDN source
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **date**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getUsagesBySourceId: function (sourceId, limit, offset, count, sorters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'sourceId' is not null or undefined
		                            (0, common_1.assertParamExists)('getUsagesBySourceId', 'sourceId', sourceId);
		                            localVarPath = "/source-usages/{sourceId}/summaries"
		                                .replace("{".concat("sourceId", "}"), encodeURIComponent(String(sourceId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.SourceUsagesApiAxiosParamCreator = SourceUsagesApiAxiosParamCreator;
		/**
		 * SourceUsagesApi - functional programming interface
		 * @export
		 */
		var SourceUsagesApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.SourceUsagesApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * This API returns the status of the source usage insights setup by IDN source ID.
		         * @summary Finds status of source usage
		         * @param {string} sourceId ID of IDN source
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getStatusBySourceId: function (sourceId, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getStatusBySourceId(sourceId, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns a summary of source usage insights for past 12 months.
		         * @summary Returns source usage insights
		         * @param {string} sourceId ID of IDN source
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **date**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getUsagesBySourceId: function (sourceId, limit, offset, count, sorters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getUsagesBySourceId(sourceId, limit, offset, count, sorters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.SourceUsagesApiFp = SourceUsagesApiFp;
		/**
		 * SourceUsagesApi - factory interface
		 * @export
		 */
		var SourceUsagesApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.SourceUsagesApiFp)(configuration);
		    return {
		        /**
		         * This API returns the status of the source usage insights setup by IDN source ID.
		         * @summary Finds status of source usage
		         * @param {string} sourceId ID of IDN source
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getStatusBySourceId: function (sourceId, axiosOptions) {
		            return localVarFp.getStatusBySourceId(sourceId, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API returns a summary of source usage insights for past 12 months.
		         * @summary Returns source usage insights
		         * @param {string} sourceId ID of IDN source
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **date**
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getUsagesBySourceId: function (sourceId, limit, offset, count, sorters, axiosOptions) {
		            return localVarFp.getUsagesBySourceId(sourceId, limit, offset, count, sorters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.SourceUsagesApiFactory = SourceUsagesApiFactory;
		/**
		 * SourceUsagesApi - object-oriented interface
		 * @export
		 * @class SourceUsagesApi
		 * @extends {BaseAPI}
		 */
		var SourceUsagesApi = /** @class */ (function (_super) {
		    __extends(SourceUsagesApi, _super);
		    function SourceUsagesApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * This API returns the status of the source usage insights setup by IDN source ID.
		     * @summary Finds status of source usage
		     * @param {SourceUsagesApiGetStatusBySourceIdRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SourceUsagesApi
		     */
		    SourceUsagesApi.prototype.getStatusBySourceId = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SourceUsagesApiFp)(this.configuration).getStatusBySourceId(requestParameters.sourceId, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API returns a summary of source usage insights for past 12 months.
		     * @summary Returns source usage insights
		     * @param {SourceUsagesApiGetUsagesBySourceIdRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SourceUsagesApi
		     */
		    SourceUsagesApi.prototype.getUsagesBySourceId = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SourceUsagesApiFp)(this.configuration).getUsagesBySourceId(requestParameters.sourceId, requestParameters.limit, requestParameters.offset, requestParameters.count, requestParameters.sorters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return SourceUsagesApi;
		}(base_1.BaseAPI));
		exports.SourceUsagesApi = SourceUsagesApi;
		/**
		 * SourcesApi - axios parameter creator
		 * @export
		 */
		var SourcesApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * This API generates a create policy/template based on field value transforms. This API is intended for use when setting up JDBC Provisioning type sources, but it will also work on other source types. Transforms can be used in the provisioning policy to create a new attribute that you only need during provisioning. Refer to [Transforms in Provisioning Policies](https://developer.sailpoint.com/idn/docs/transforms/guides/transforms-in-provisioning-policies) for more information. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Create Provisioning Policy
		         * @param {string} sourceId The Source id
		         * @param {ProvisioningPolicyDto} provisioningPolicyDto
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createProvisioningPolicy: function (sourceId, provisioningPolicyDto, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'sourceId' is not null or undefined
		                            (0, common_1.assertParamExists)('createProvisioningPolicy', 'sourceId', sourceId);
		                            // verify required parameter 'provisioningPolicyDto' is not null or undefined
		                            (0, common_1.assertParamExists)('createProvisioningPolicy', 'provisioningPolicyDto', provisioningPolicyDto);
		                            localVarPath = "/sources/{sourceId}/provisioning-policies"
		                                .replace("{".concat("sourceId", "}"), encodeURIComponent(String(sourceId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(provisioningPolicyDto, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This creates a specific source with a full source JSON representation. Any passwords are submitted as plain-text and encrypted upon receipt in IdentityNow. A token with ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		         * @summary Creates a source in IdentityNow.
		         * @param {Source} source
		         * @param {boolean} [provisionAsCsv] If this parameter is &#x60;true&#x60;, it configures the source as a Delimited File (CSV) source. Setting this to &#x60;true&#x60; will automatically set the &#x60;type&#x60; of the source to &#x60;DelimitedFile&#x60;.  You must use this query parameter to create a Delimited File source as you would in the UI.  If you don\&#39;t set this query parameter and you attempt to set the &#x60;type&#x60; attribute directly, the request won\&#39;t correctly generate the source.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createSource: function (source, provisionAsCsv, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'source' is not null or undefined
		                            (0, common_1.assertParamExists)('createSource', 'source', source);
		                            localVarPath = "/sources";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (provisionAsCsv !== undefined) {
		                                localVarQueryParameter['provisionAsCsv'] = provisionAsCsv;
		                            }
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(source, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Creates a new Schema on the specified Source in IdentityNow.
		         * @summary Create Schema on a Source
		         * @param {string} sourceId The Source id.
		         * @param {Schema} schema
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createSourceSchema: function (sourceId, schema, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'sourceId' is not null or undefined
		                            (0, common_1.assertParamExists)('createSourceSchema', 'sourceId', sourceId);
		                            // verify required parameter 'schema' is not null or undefined
		                            (0, common_1.assertParamExists)('createSourceSchema', 'schema', schema);
		                            localVarPath = "/sources/{sourceId}/schemas"
		                                .replace("{".concat("sourceId", "}"), encodeURIComponent(String(sourceId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(schema, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Deletes the provisioning policy with the specified usage on an application. A token with API, or ORG_ADMIN authority is required to call this API.
		         * @summary Delete Provisioning Policy by UsageType
		         * @param {string} sourceId The Source ID.
		         * @param {UsageType} usageType The type of provisioning policy usage.  In IdentityNow, a source can support various provisioning operations. For example, when a joiner is added to a source, this may trigger both CREATE and UPDATE provisioning operations.  Each usage type is considered a provisioning policy.  A source can have any number of these provisioning policies defined.  These are the common usage types:  CREATE - This usage type relates to \&#39;Create Account Profile\&#39;, the provisioning template for the account to be created. For example, this would be used for a joiner on a source.   UPDATE - This usage type relates to \&#39;Update Account Profile\&#39;, the provisioning template for the \&#39;Update\&#39; connector operations. For example, this would be used for an attribute sync on a source. ENABLE - This usage type relates to \&#39;Enable Account Profile\&#39;, the provisioning template for the account to be enabled. For example, this could be used for a joiner on a source once the joiner\&#39;s account is created.  DISABLE - This usage type relates to \&#39;Disable Account Profile\&#39;, the provisioning template for the account to be disabled. For example, this could be used when a leaver is removed temporarily from a source.  You can use these four usage types for all your provisioning policy needs.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteProvisioningPolicy: function (sourceId, usageType, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'sourceId' is not null or undefined
		                            (0, common_1.assertParamExists)('deleteProvisioningPolicy', 'sourceId', sourceId);
		                            // verify required parameter 'usageType' is not null or undefined
		                            (0, common_1.assertParamExists)('deleteProvisioningPolicy', 'usageType', usageType);
		                            localVarPath = "/sources/{sourceId}/provisioning-policies/{usageType}"
		                                .replace("{".concat("sourceId", "}"), encodeURIComponent(String(sourceId)))
		                                .replace("{".concat("usageType", "}"), encodeURIComponent(String(usageType)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'DELETE' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This end-point deletes a specific source in IdentityNow. A token with ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API. All of accounts on the source will be removed first, then the source will be deleted. Actual status of task execution can be retrieved via method GET `/task-status/{id}`
		         * @summary Delete Source by ID
		         * @param {string} id The Source id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteSource: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('deleteSource', 'id', id);
		                            localVarPath = "/sources/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'DELETE' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         *
		         * @summary Delete Source Schema by ID
		         * @param {string} sourceId The Source id.
		         * @param {string} schemaId The Schema id.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteSourceSchema: function (sourceId, schemaId, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'sourceId' is not null or undefined
		                            (0, common_1.assertParamExists)('deleteSourceSchema', 'sourceId', sourceId);
		                            // verify required parameter 'schemaId' is not null or undefined
		                            (0, common_1.assertParamExists)('deleteSourceSchema', 'schemaId', schemaId);
		                            localVarPath = "/sources/{sourceId}/schemas/{schemaId}"
		                                .replace("{".concat("sourceId", "}"), encodeURIComponent(String(sourceId)))
		                                .replace("{".concat("schemaId", "}"), encodeURIComponent(String(schemaId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'DELETE' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API downloads the CSV schema that defines the account attributes on a source. >**NOTE: This API is designated only for Delimited File sources.**
		         * @summary Downloads source accounts schema template
		         * @param {string} id The Source id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getAccountsSchema: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getAccountsSchema', 'id', id);
		                            localVarPath = "/sources/{id}/schemas/accounts"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API downloads the CSV schema that defines the entitlement attributes on a source.  >**NOTE: This API is designated only for Delimited File sources.**
		         * @summary Downloads source entitlements schema template
		         * @param {string} id The Source id
		         * @param {string} [schemaName] Name of entitlement schema
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getEntitlementsSchema: function (id, schemaName, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getEntitlementsSchema', 'id', id);
		                            localVarPath = "/sources/{id}/schemas/entitlements"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (schemaName !== undefined) {
		                                localVarQueryParameter['schemaName'] = schemaName;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This end-point retrieves the ProvisioningPolicy with the specified usage on the specified Source in IdentityNow. A token with API, ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		         * @summary Get Provisioning Policy by UsageType
		         * @param {string} sourceId The Source ID.
		         * @param {UsageType} usageType The type of provisioning policy usage.  In IdentityNow, a source can support various provisioning operations. For example, when a joiner is added to a source, this may trigger both CREATE and UPDATE provisioning operations.  Each usage type is considered a provisioning policy.  A source can have any number of these provisioning policies defined.  These are the common usage types:  CREATE - This usage type relates to \&#39;Create Account Profile\&#39;, the provisioning template for the account to be created. For example, this would be used for a joiner on a source.   UPDATE - This usage type relates to \&#39;Update Account Profile\&#39;, the provisioning template for the \&#39;Update\&#39; connector operations. For example, this would be used for an attribute sync on a source. ENABLE - This usage type relates to \&#39;Enable Account Profile\&#39;, the provisioning template for the account to be enabled. For example, this could be used for a joiner on a source once the joiner\&#39;s account is created.  DISABLE - This usage type relates to \&#39;Disable Account Profile\&#39;, the provisioning template for the account to be disabled. For example, this could be used when a leaver is removed temporarily from a source.  You can use these four usage types for all your provisioning policy needs.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getProvisioningPolicy: function (sourceId, usageType, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'sourceId' is not null or undefined
		                            (0, common_1.assertParamExists)('getProvisioningPolicy', 'sourceId', sourceId);
		                            // verify required parameter 'usageType' is not null or undefined
		                            (0, common_1.assertParamExists)('getProvisioningPolicy', 'usageType', usageType);
		                            localVarPath = "/sources/{sourceId}/provisioning-policies/{usageType}"
		                                .replace("{".concat("sourceId", "}"), encodeURIComponent(String(sourceId)))
		                                .replace("{".concat("usageType", "}"), encodeURIComponent(String(usageType)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This end-point gets a specific source in IdentityNow. A token with ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		         * @summary Get Source by ID
		         * @param {string} id The Source id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getSource: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getSource', 'id', id);
		                            localVarPath = "/sources/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This endpoint fetches source health by source\'s id
		         * @summary Fetches source health by id
		         * @param {string} sourceId The Source id.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getSourceHealth: function (sourceId, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'sourceId' is not null or undefined
		                            (0, common_1.assertParamExists)('getSourceHealth', 'sourceId', sourceId);
		                            localVarPath = "/sources/{sourceId}/source-health"
		                                .replace("{".concat("sourceId", "}"), encodeURIComponent(String(sourceId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Get the Source Schema by ID in IdentityNow.
		         * @summary Get Source Schema by ID
		         * @param {string} sourceId The Source id.
		         * @param {string} schemaId The Schema id.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getSourceSchema: function (sourceId, schemaId, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'sourceId' is not null or undefined
		                            (0, common_1.assertParamExists)('getSourceSchema', 'sourceId', sourceId);
		                            // verify required parameter 'schemaId' is not null or undefined
		                            (0, common_1.assertParamExists)('getSourceSchema', 'schemaId', schemaId);
		                            localVarPath = "/sources/{sourceId}/schemas/{schemaId}"
		                                .replace("{".concat("sourceId", "}"), encodeURIComponent(String(sourceId)))
		                                .replace("{".concat("schemaId", "}"), encodeURIComponent(String(schemaId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API uploads a source schema template file to configure a source\'s account attributes.  To retrieve the file to modify and upload, log into Identity Now.   Click **Admin** -> **Connections** -> **Sources** -> **`{SourceName}`** -> **Import Data** -> **Account Schema** -> **Options** -> **Download Schema**  >**NOTE: This API is designated only for Delimited File sources.**
		         * @summary Uploads source accounts schema template
		         * @param {string} id The Source id
		         * @param {any} [file]
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        importAccountsSchema: function (id, file, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, localVarFormParams, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('importAccountsSchema', 'id', id);
		                            localVarPath = "/sources/{id}/schemas/accounts"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            localVarFormParams = new ((configuration && configuration.formDataCtor) || FormData)();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (file !== undefined) {
		                                localVarFormParams.append('file', file);
		                            }
		                            localVarHeaderParameter['Content-Type'] = 'multipart/form-data';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = localVarFormParams;
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This uploads a supplemental source connector file (like jdbc driver jars) to a source\'s S3 bucket. This also sends ETS and Audit events. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Upload connector file to source
		         * @param {string} sourceId The Source id.
		         * @param {any} [file]
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        importConnectorFile: function (sourceId, file, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, localVarFormParams, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'sourceId' is not null or undefined
		                            (0, common_1.assertParamExists)('importConnectorFile', 'sourceId', sourceId);
		                            localVarPath = "/sources/{sourceId}/upload-connector-file"
		                                .replace("{".concat("sourceId", "}"), encodeURIComponent(String(sourceId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            localVarFormParams = new ((configuration && configuration.formDataCtor) || FormData)();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (file !== undefined) {
		                                localVarFormParams.append('file', file);
		                            }
		                            localVarHeaderParameter['Content-Type'] = 'multipart/form-data';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = localVarFormParams;
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API uploads a source schema template file to configure a source\'s entitlement attributes.  To retrieve the file to modify and upload, log into Identity Now.   Click **Admin** -> **Connections** -> **Sources** -> **`{SourceName}`** -> **Import Data** -> **Import Entitlements** -> **Download**  >**NOTE: This API is designated only for Delimited File sources.**
		         * @summary Uploads source entitlements schema template
		         * @param {string} id The Source id
		         * @param {string} [schemaName] Name of entitlement schema
		         * @param {any} [file]
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        importEntitlementsSchema: function (id, schemaName, file, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, localVarFormParams, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('importEntitlementsSchema', 'id', id);
		                            localVarPath = "/sources/{id}/schemas/entitlements"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            localVarFormParams = new ((configuration && configuration.formDataCtor) || FormData)();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (schemaName !== undefined) {
		                                localVarQueryParameter['schemaName'] = schemaName;
		                            }
		                            if (file !== undefined) {
		                                localVarFormParams.append('file', file);
		                            }
		                            localVarHeaderParameter['Content-Type'] = 'multipart/form-data';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = localVarFormParams;
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This end-point lists all the ProvisioningPolicies in IdentityNow. A token with API, or ORG_ADMIN authority is required to call this API.
		         * @summary Lists ProvisioningPolicies
		         * @param {string} sourceId The Source id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listProvisioningPolicies: function (sourceId, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'sourceId' is not null or undefined
		                            (0, common_1.assertParamExists)('listProvisioningPolicies', 'sourceId', sourceId);
		                            localVarPath = "/sources/{sourceId}/provisioning-policies"
		                                .replace("{".concat("sourceId", "}"), encodeURIComponent(String(sourceId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Lists the Schemas that exist on the specified Source in IdentityNow.
		         * @summary List Schemas on a Source
		         * @param {string} sourceId The Source ID.
		         * @param {string} [includeTypes] If set to \&#39;group\&#39;, then the account schema is filtered and only group schemas are returned. Only a value of \&#39;group\&#39; is recognized.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listSourceSchemas: function (sourceId, includeTypes, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'sourceId' is not null or undefined
		                            (0, common_1.assertParamExists)('listSourceSchemas', 'sourceId', sourceId);
		                            localVarPath = "/sources/{sourceId}/schemas"
		                                .replace("{".concat("sourceId", "}"), encodeURIComponent(String(sourceId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (includeTypes !== undefined) {
		                                localVarQueryParameter['include-types'] = includeTypes;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This end-point lists all the sources in IdentityNow. A token with ORG_ADMIN, SOURCE_ADMIN, SOURCE_SUBADMIN, or ROLE_SUBADMIN authority is required to call this API.
		         * @summary Lists all sources in IdentityNow.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in, ge, gt, le, lt, ne, isnull, sw*  **name**: *co, eq, in, sw, ge, gt, ne, isnull*  **type**: *eq, in, ge, gt, ne, isnull, sw*  **owner.id**: *eq, in, ge, gt, le, lt, ne, isnull, sw*  **features**: *ca, co*  **created**: *eq, ge, gt, in, le, lt, ne, isnull, sw*  **modified**: *eq, ge, gt, in, le, lt, ne, isnull, sw*  **managementWorkgroup.id**: *eq, ge, gt, in, le, lt, ne, isnull, sw*  **description**: *eq, sw*  **authoritative**: *eq, ne, isnull*  **healthy**: *isnull*  **status**: *eq, in, ge, gt, le, lt, ne, isnull, sw*  **connectionType**: *eq, ge, gt, in, le, lt, ne, isnull, sw*  **connectorName**: *eq, ge, gt, in, ne, isnull, sw*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **type, created, modified, name, owner.name, healthy, status, id, description, owner.id, accountCorrelationConfig.id, accountCorrelationConfig.name, managerCorrelationRule.type, managerCorrelationRule.id, managerCorrelationRule.name, authoritative, managementWorkgroup.id, connectorName, connectionType**
		         * @param {string} [forSubadmin] Filter the returned list of sources for the identity specified by the parameter, which is the id of an identity with the role SOURCE_SUBADMIN. By convention, the value **me** indicates the identity id of the current user. Subadmins may only view Sources which they are able to administer; all other Sources will be filtered out when this parameter is set. If the current user is a SOURCE_SUBADMIN but fails to pass a valid value for this parameter, a 403 Forbidden is returned.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listSources: function (limit, offset, count, filters, sorters, forSubadmin, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/sources";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            if (sorters !== undefined) {
		                                localVarQueryParameter['sorters'] = sorters;
		                            }
		                            if (forSubadmin !== undefined) {
		                                localVarQueryParameter['for-subadmin'] = forSubadmin;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This end-point updates the provisioning policy with the specified usage on the specified source in IdentityNow. Transforms can be used in the provisioning policy to create a new attribute that you only need during provisioning. Refer to [Transforms in Provisioning Policies](https://developer.sailpoint.com/idn/docs/transforms/guides/transforms-in-provisioning-policies) for more information. A token with API, ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		         * @summary Update Provisioning Policy by UsageType
		         * @param {string} sourceId The Source ID.
		         * @param {UsageType} usageType The type of provisioning policy usage.  In IdentityNow, a source can support various provisioning operations. For example, when a joiner is added to a source, this may trigger both CREATE and UPDATE provisioning operations.  Each usage type is considered a provisioning policy.  A source can have any number of these provisioning policies defined.  These are the common usage types:  CREATE - This usage type relates to \&#39;Create Account Profile\&#39;, the provisioning template for the account to be created. For example, this would be used for a joiner on a source.   UPDATE - This usage type relates to \&#39;Update Account Profile\&#39;, the provisioning template for the \&#39;Update\&#39; connector operations. For example, this would be used for an attribute sync on a source. ENABLE - This usage type relates to \&#39;Enable Account Profile\&#39;, the provisioning template for the account to be enabled. For example, this could be used for a joiner on a source once the joiner\&#39;s account is created.  DISABLE - This usage type relates to \&#39;Disable Account Profile\&#39;, the provisioning template for the account to be disabled. For example, this could be used when a leaver is removed temporarily from a source.  You can use these four usage types for all your provisioning policy needs.
		         * @param {ProvisioningPolicyDto} provisioningPolicyDto
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putProvisioningPolicy: function (sourceId, usageType, provisioningPolicyDto, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'sourceId' is not null or undefined
		                            (0, common_1.assertParamExists)('putProvisioningPolicy', 'sourceId', sourceId);
		                            // verify required parameter 'usageType' is not null or undefined
		                            (0, common_1.assertParamExists)('putProvisioningPolicy', 'usageType', usageType);
		                            // verify required parameter 'provisioningPolicyDto' is not null or undefined
		                            (0, common_1.assertParamExists)('putProvisioningPolicy', 'provisioningPolicyDto', provisioningPolicyDto);
		                            localVarPath = "/sources/{sourceId}/provisioning-policies/{usageType}"
		                                .replace("{".concat("sourceId", "}"), encodeURIComponent(String(sourceId)))
		                                .replace("{".concat("usageType", "}"), encodeURIComponent(String(usageType)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PUT' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(provisioningPolicyDto, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API updates a source in IdentityNow, using a full object representation. In other words, the existing Source configuration is completely replaced.  Some fields are immutable and cannot be changed, such as:  * id * type * authoritative * connector * connectorClass * passwordPolicies  Attempts to modify these fields will result in a 400 error.  A token with ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		         * @summary Update Source (Full)
		         * @param {string} id The Source id
		         * @param {Source} source
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putSource: function (id, source, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('putSource', 'id', id);
		                            // verify required parameter 'source' is not null or undefined
		                            (0, common_1.assertParamExists)('putSource', 'source', source);
		                            localVarPath = "/sources/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PUT' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(source, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API will completely replace an existing Schema with the submitted payload. Some fields of the Schema cannot be updated. These fields are listed below.  * id * name * created * modified  Any attempt to modify these fields will result in an error response with a status code of 400.  > `id` must remain in the request body, but it cannot be changed.  If `id` is omitted from the request body, the result will be a 400 error.
		         * @summary Update Source Schema (Full)
		         * @param {string} sourceId The Source id.
		         * @param {string} schemaId The Schema id.
		         * @param {Schema} schema
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putSourceSchema: function (sourceId, schemaId, schema, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'sourceId' is not null or undefined
		                            (0, common_1.assertParamExists)('putSourceSchema', 'sourceId', sourceId);
		                            // verify required parameter 'schemaId' is not null or undefined
		                            (0, common_1.assertParamExists)('putSourceSchema', 'schemaId', schemaId);
		                            // verify required parameter 'schema' is not null or undefined
		                            (0, common_1.assertParamExists)('putSourceSchema', 'schema', schema);
		                            localVarPath = "/sources/{sourceId}/schemas/{schemaId}"
		                                .replace("{".concat("sourceId", "}"), encodeURIComponent(String(sourceId)))
		                                .replace("{".concat("schemaId", "}"), encodeURIComponent(String(schemaId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PUT' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(schema, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This end-point updates a list of provisioning policies on the specified source in IdentityNow. A token with API, or ORG_ADMIN authority is required to call this API.
		         * @summary Bulk Update Provisioning Policies
		         * @param {string} sourceId The Source id.
		         * @param {Array<ProvisioningPolicyDto>} provisioningPolicyDto
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateProvisioningPoliciesInBulk: function (sourceId, provisioningPolicyDto, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'sourceId' is not null or undefined
		                            (0, common_1.assertParamExists)('updateProvisioningPoliciesInBulk', 'sourceId', sourceId);
		                            // verify required parameter 'provisioningPolicyDto' is not null or undefined
		                            (0, common_1.assertParamExists)('updateProvisioningPoliciesInBulk', 'provisioningPolicyDto', provisioningPolicyDto);
		                            localVarPath = "/sources/{sourceId}/provisioning-policies/bulk-update"
		                                .replace("{".concat("sourceId", "}"), encodeURIComponent(String(sourceId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(provisioningPolicyDto, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API selectively updates an existing Provisioning Policy using a JSONPatch payload. Transforms can be used in the provisioning policy to create a new attribute that you only need during provisioning. Refer to [Transforms in Provisioning Policies](https://developer.sailpoint.com/idn/docs/transforms/guides/transforms-in-provisioning-policies) for more information. A token with API, ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		         * @summary Partial update of Provisioning Policy
		         * @param {string} sourceId The Source id.
		         * @param {UsageType} usageType The type of provisioning policy usage.  In IdentityNow, a source can support various provisioning operations. For example, when a joiner is added to a source, this may trigger both CREATE and UPDATE provisioning operations.  Each usage type is considered a provisioning policy.  A source can have any number of these provisioning policies defined.  These are the common usage types:  CREATE - This usage type relates to \&#39;Create Account Profile\&#39;, the provisioning template for the account to be created. For example, this would be used for a joiner on a source.   UPDATE - This usage type relates to \&#39;Update Account Profile\&#39;, the provisioning template for the \&#39;Update\&#39; connector operations. For example, this would be used for an attribute sync on a source. ENABLE - This usage type relates to \&#39;Enable Account Profile\&#39;, the provisioning template for the account to be enabled. For example, this could be used for a joiner on a source once the joiner\&#39;s account is created.  DISABLE - This usage type relates to \&#39;Disable Account Profile\&#39;, the provisioning template for the account to be disabled. For example, this could be used when a leaver is removed temporarily from a source.  You can use these four usage types for all your provisioning policy needs.
		         * @param {Array<JsonPatchOperation>} jsonPatchOperation The JSONPatch payload used to update the schema.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateProvisioningPolicy: function (sourceId, usageType, jsonPatchOperation, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'sourceId' is not null or undefined
		                            (0, common_1.assertParamExists)('updateProvisioningPolicy', 'sourceId', sourceId);
		                            // verify required parameter 'usageType' is not null or undefined
		                            (0, common_1.assertParamExists)('updateProvisioningPolicy', 'usageType', usageType);
		                            // verify required parameter 'jsonPatchOperation' is not null or undefined
		                            (0, common_1.assertParamExists)('updateProvisioningPolicy', 'jsonPatchOperation', jsonPatchOperation);
		                            localVarPath = "/sources/{sourceId}/provisioning-policies/{usageType}"
		                                .replace("{".concat("sourceId", "}"), encodeURIComponent(String(sourceId)))
		                                .replace("{".concat("usageType", "}"), encodeURIComponent(String(usageType)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PATCH' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json-patch+json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(jsonPatchOperation, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API partially updates a source in IdentityNow, using a list of patch operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.  Some fields are immutable and cannot be changed, such as:  * id * type * authoritative * created * modified * connector * connectorClass * passwordPolicies  Attempts to modify these fields will result in a 400 error.  A token with ORG_ADMIN, SOURCE_ADMIN, SOURCE_SUBADMIN, or API authority is required to call this API.
		         * @summary Update Source (Partial)
		         * @param {string} id The Source id
		         * @param {Array<JsonPatchOperation>} jsonPatchOperation A list of account update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard. Any password changes are submitted as plain-text and encrypted upon receipt in IdentityNow.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateSource: function (id, jsonPatchOperation, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('updateSource', 'id', id);
		                            // verify required parameter 'jsonPatchOperation' is not null or undefined
		                            (0, common_1.assertParamExists)('updateSource', 'jsonPatchOperation', jsonPatchOperation);
		                            localVarPath = "/sources/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PATCH' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json-patch+json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(jsonPatchOperation, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Use this API to selectively update an existing Schema using a JSONPatch payload.   The following schema fields are immutable and cannot be updated:  - id - name - created - modified   To switch an account attribute to a group entitlement, you need to have the following in place:  - `isEntitlement: true` - Must define a schema for the group and [add it to the source](https://developer.sailpoint.com/idn/api/v3/create-source-schema) before updating the `isGroup` flag.  For example, here is the `group` account attribute referencing a schema that defines the group: ```json {     \"name\": \"groups\",     \"type\": \"STRING\",     \"schema\": {         \"type\": \"CONNECTOR_SCHEMA\",         \"id\": \"2c9180887671ff8c01767b4671fc7d60\",         \"name\": \"group\"     },     \"description\": \"The groups, roles etc. that reference account group objects\",     \"isMulti\": true,     \"isEntitlement\": true,     \"isGroup\": true } ```
		         * @summary Update Source Schema (Partial)
		         * @param {string} sourceId The Source id.
		         * @param {string} schemaId The Schema id.
		         * @param {Array<JsonPatchOperation>} jsonPatchOperation The JSONPatch payload used to update the schema.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateSourceSchema: function (sourceId, schemaId, jsonPatchOperation, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'sourceId' is not null or undefined
		                            (0, common_1.assertParamExists)('updateSourceSchema', 'sourceId', sourceId);
		                            // verify required parameter 'schemaId' is not null or undefined
		                            (0, common_1.assertParamExists)('updateSourceSchema', 'schemaId', schemaId);
		                            // verify required parameter 'jsonPatchOperation' is not null or undefined
		                            (0, common_1.assertParamExists)('updateSourceSchema', 'jsonPatchOperation', jsonPatchOperation);
		                            localVarPath = "/sources/{sourceId}/schemas/{schemaId}"
		                                .replace("{".concat("sourceId", "}"), encodeURIComponent(String(sourceId)))
		                                .replace("{".concat("schemaId", "}"), encodeURIComponent(String(schemaId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PATCH' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json-patch+json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(jsonPatchOperation, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.SourcesApiAxiosParamCreator = SourcesApiAxiosParamCreator;
		/**
		 * SourcesApi - functional programming interface
		 * @export
		 */
		var SourcesApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.SourcesApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * This API generates a create policy/template based on field value transforms. This API is intended for use when setting up JDBC Provisioning type sources, but it will also work on other source types. Transforms can be used in the provisioning policy to create a new attribute that you only need during provisioning. Refer to [Transforms in Provisioning Policies](https://developer.sailpoint.com/idn/docs/transforms/guides/transforms-in-provisioning-policies) for more information. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Create Provisioning Policy
		         * @param {string} sourceId The Source id
		         * @param {ProvisioningPolicyDto} provisioningPolicyDto
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createProvisioningPolicy: function (sourceId, provisioningPolicyDto, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.createProvisioningPolicy(sourceId, provisioningPolicyDto, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This creates a specific source with a full source JSON representation. Any passwords are submitted as plain-text and encrypted upon receipt in IdentityNow. A token with ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		         * @summary Creates a source in IdentityNow.
		         * @param {Source} source
		         * @param {boolean} [provisionAsCsv] If this parameter is &#x60;true&#x60;, it configures the source as a Delimited File (CSV) source. Setting this to &#x60;true&#x60; will automatically set the &#x60;type&#x60; of the source to &#x60;DelimitedFile&#x60;.  You must use this query parameter to create a Delimited File source as you would in the UI.  If you don\&#39;t set this query parameter and you attempt to set the &#x60;type&#x60; attribute directly, the request won\&#39;t correctly generate the source.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createSource: function (source, provisionAsCsv, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.createSource(source, provisionAsCsv, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Creates a new Schema on the specified Source in IdentityNow.
		         * @summary Create Schema on a Source
		         * @param {string} sourceId The Source id.
		         * @param {Schema} schema
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createSourceSchema: function (sourceId, schema, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.createSourceSchema(sourceId, schema, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Deletes the provisioning policy with the specified usage on an application. A token with API, or ORG_ADMIN authority is required to call this API.
		         * @summary Delete Provisioning Policy by UsageType
		         * @param {string} sourceId The Source ID.
		         * @param {UsageType} usageType The type of provisioning policy usage.  In IdentityNow, a source can support various provisioning operations. For example, when a joiner is added to a source, this may trigger both CREATE and UPDATE provisioning operations.  Each usage type is considered a provisioning policy.  A source can have any number of these provisioning policies defined.  These are the common usage types:  CREATE - This usage type relates to \&#39;Create Account Profile\&#39;, the provisioning template for the account to be created. For example, this would be used for a joiner on a source.   UPDATE - This usage type relates to \&#39;Update Account Profile\&#39;, the provisioning template for the \&#39;Update\&#39; connector operations. For example, this would be used for an attribute sync on a source. ENABLE - This usage type relates to \&#39;Enable Account Profile\&#39;, the provisioning template for the account to be enabled. For example, this could be used for a joiner on a source once the joiner\&#39;s account is created.  DISABLE - This usage type relates to \&#39;Disable Account Profile\&#39;, the provisioning template for the account to be disabled. For example, this could be used when a leaver is removed temporarily from a source.  You can use these four usage types for all your provisioning policy needs.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteProvisioningPolicy: function (sourceId, usageType, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.deleteProvisioningPolicy(sourceId, usageType, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This end-point deletes a specific source in IdentityNow. A token with ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API. All of accounts on the source will be removed first, then the source will be deleted. Actual status of task execution can be retrieved via method GET `/task-status/{id}`
		         * @summary Delete Source by ID
		         * @param {string} id The Source id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteSource: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.deleteSource(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         *
		         * @summary Delete Source Schema by ID
		         * @param {string} sourceId The Source id.
		         * @param {string} schemaId The Schema id.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteSourceSchema: function (sourceId, schemaId, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.deleteSourceSchema(sourceId, schemaId, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API downloads the CSV schema that defines the account attributes on a source. >**NOTE: This API is designated only for Delimited File sources.**
		         * @summary Downloads source accounts schema template
		         * @param {string} id The Source id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getAccountsSchema: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getAccountsSchema(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API downloads the CSV schema that defines the entitlement attributes on a source.  >**NOTE: This API is designated only for Delimited File sources.**
		         * @summary Downloads source entitlements schema template
		         * @param {string} id The Source id
		         * @param {string} [schemaName] Name of entitlement schema
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getEntitlementsSchema: function (id, schemaName, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getEntitlementsSchema(id, schemaName, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This end-point retrieves the ProvisioningPolicy with the specified usage on the specified Source in IdentityNow. A token with API, ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		         * @summary Get Provisioning Policy by UsageType
		         * @param {string} sourceId The Source ID.
		         * @param {UsageType} usageType The type of provisioning policy usage.  In IdentityNow, a source can support various provisioning operations. For example, when a joiner is added to a source, this may trigger both CREATE and UPDATE provisioning operations.  Each usage type is considered a provisioning policy.  A source can have any number of these provisioning policies defined.  These are the common usage types:  CREATE - This usage type relates to \&#39;Create Account Profile\&#39;, the provisioning template for the account to be created. For example, this would be used for a joiner on a source.   UPDATE - This usage type relates to \&#39;Update Account Profile\&#39;, the provisioning template for the \&#39;Update\&#39; connector operations. For example, this would be used for an attribute sync on a source. ENABLE - This usage type relates to \&#39;Enable Account Profile\&#39;, the provisioning template for the account to be enabled. For example, this could be used for a joiner on a source once the joiner\&#39;s account is created.  DISABLE - This usage type relates to \&#39;Disable Account Profile\&#39;, the provisioning template for the account to be disabled. For example, this could be used when a leaver is removed temporarily from a source.  You can use these four usage types for all your provisioning policy needs.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getProvisioningPolicy: function (sourceId, usageType, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getProvisioningPolicy(sourceId, usageType, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This end-point gets a specific source in IdentityNow. A token with ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		         * @summary Get Source by ID
		         * @param {string} id The Source id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getSource: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getSource(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This endpoint fetches source health by source\'s id
		         * @summary Fetches source health by id
		         * @param {string} sourceId The Source id.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getSourceHealth: function (sourceId, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getSourceHealth(sourceId, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Get the Source Schema by ID in IdentityNow.
		         * @summary Get Source Schema by ID
		         * @param {string} sourceId The Source id.
		         * @param {string} schemaId The Schema id.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getSourceSchema: function (sourceId, schemaId, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getSourceSchema(sourceId, schemaId, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API uploads a source schema template file to configure a source\'s account attributes.  To retrieve the file to modify and upload, log into Identity Now.   Click **Admin** -> **Connections** -> **Sources** -> **`{SourceName}`** -> **Import Data** -> **Account Schema** -> **Options** -> **Download Schema**  >**NOTE: This API is designated only for Delimited File sources.**
		         * @summary Uploads source accounts schema template
		         * @param {string} id The Source id
		         * @param {any} [file]
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        importAccountsSchema: function (id, file, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.importAccountsSchema(id, file, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This uploads a supplemental source connector file (like jdbc driver jars) to a source\'s S3 bucket. This also sends ETS and Audit events. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Upload connector file to source
		         * @param {string} sourceId The Source id.
		         * @param {any} [file]
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        importConnectorFile: function (sourceId, file, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.importConnectorFile(sourceId, file, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API uploads a source schema template file to configure a source\'s entitlement attributes.  To retrieve the file to modify and upload, log into Identity Now.   Click **Admin** -> **Connections** -> **Sources** -> **`{SourceName}`** -> **Import Data** -> **Import Entitlements** -> **Download**  >**NOTE: This API is designated only for Delimited File sources.**
		         * @summary Uploads source entitlements schema template
		         * @param {string} id The Source id
		         * @param {string} [schemaName] Name of entitlement schema
		         * @param {any} [file]
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        importEntitlementsSchema: function (id, schemaName, file, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.importEntitlementsSchema(id, schemaName, file, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This end-point lists all the ProvisioningPolicies in IdentityNow. A token with API, or ORG_ADMIN authority is required to call this API.
		         * @summary Lists ProvisioningPolicies
		         * @param {string} sourceId The Source id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listProvisioningPolicies: function (sourceId, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listProvisioningPolicies(sourceId, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Lists the Schemas that exist on the specified Source in IdentityNow.
		         * @summary List Schemas on a Source
		         * @param {string} sourceId The Source ID.
		         * @param {string} [includeTypes] If set to \&#39;group\&#39;, then the account schema is filtered and only group schemas are returned. Only a value of \&#39;group\&#39; is recognized.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listSourceSchemas: function (sourceId, includeTypes, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listSourceSchemas(sourceId, includeTypes, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This end-point lists all the sources in IdentityNow. A token with ORG_ADMIN, SOURCE_ADMIN, SOURCE_SUBADMIN, or ROLE_SUBADMIN authority is required to call this API.
		         * @summary Lists all sources in IdentityNow.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in, ge, gt, le, lt, ne, isnull, sw*  **name**: *co, eq, in, sw, ge, gt, ne, isnull*  **type**: *eq, in, ge, gt, ne, isnull, sw*  **owner.id**: *eq, in, ge, gt, le, lt, ne, isnull, sw*  **features**: *ca, co*  **created**: *eq, ge, gt, in, le, lt, ne, isnull, sw*  **modified**: *eq, ge, gt, in, le, lt, ne, isnull, sw*  **managementWorkgroup.id**: *eq, ge, gt, in, le, lt, ne, isnull, sw*  **description**: *eq, sw*  **authoritative**: *eq, ne, isnull*  **healthy**: *isnull*  **status**: *eq, in, ge, gt, le, lt, ne, isnull, sw*  **connectionType**: *eq, ge, gt, in, le, lt, ne, isnull, sw*  **connectorName**: *eq, ge, gt, in, ne, isnull, sw*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **type, created, modified, name, owner.name, healthy, status, id, description, owner.id, accountCorrelationConfig.id, accountCorrelationConfig.name, managerCorrelationRule.type, managerCorrelationRule.id, managerCorrelationRule.name, authoritative, managementWorkgroup.id, connectorName, connectionType**
		         * @param {string} [forSubadmin] Filter the returned list of sources for the identity specified by the parameter, which is the id of an identity with the role SOURCE_SUBADMIN. By convention, the value **me** indicates the identity id of the current user. Subadmins may only view Sources which they are able to administer; all other Sources will be filtered out when this parameter is set. If the current user is a SOURCE_SUBADMIN but fails to pass a valid value for this parameter, a 403 Forbidden is returned.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listSources: function (limit, offset, count, filters, sorters, forSubadmin, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listSources(limit, offset, count, filters, sorters, forSubadmin, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This end-point updates the provisioning policy with the specified usage on the specified source in IdentityNow. Transforms can be used in the provisioning policy to create a new attribute that you only need during provisioning. Refer to [Transforms in Provisioning Policies](https://developer.sailpoint.com/idn/docs/transforms/guides/transforms-in-provisioning-policies) for more information. A token with API, ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		         * @summary Update Provisioning Policy by UsageType
		         * @param {string} sourceId The Source ID.
		         * @param {UsageType} usageType The type of provisioning policy usage.  In IdentityNow, a source can support various provisioning operations. For example, when a joiner is added to a source, this may trigger both CREATE and UPDATE provisioning operations.  Each usage type is considered a provisioning policy.  A source can have any number of these provisioning policies defined.  These are the common usage types:  CREATE - This usage type relates to \&#39;Create Account Profile\&#39;, the provisioning template for the account to be created. For example, this would be used for a joiner on a source.   UPDATE - This usage type relates to \&#39;Update Account Profile\&#39;, the provisioning template for the \&#39;Update\&#39; connector operations. For example, this would be used for an attribute sync on a source. ENABLE - This usage type relates to \&#39;Enable Account Profile\&#39;, the provisioning template for the account to be enabled. For example, this could be used for a joiner on a source once the joiner\&#39;s account is created.  DISABLE - This usage type relates to \&#39;Disable Account Profile\&#39;, the provisioning template for the account to be disabled. For example, this could be used when a leaver is removed temporarily from a source.  You can use these four usage types for all your provisioning policy needs.
		         * @param {ProvisioningPolicyDto} provisioningPolicyDto
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putProvisioningPolicy: function (sourceId, usageType, provisioningPolicyDto, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.putProvisioningPolicy(sourceId, usageType, provisioningPolicyDto, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API updates a source in IdentityNow, using a full object representation. In other words, the existing Source configuration is completely replaced.  Some fields are immutable and cannot be changed, such as:  * id * type * authoritative * connector * connectorClass * passwordPolicies  Attempts to modify these fields will result in a 400 error.  A token with ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		         * @summary Update Source (Full)
		         * @param {string} id The Source id
		         * @param {Source} source
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putSource: function (id, source, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.putSource(id, source, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API will completely replace an existing Schema with the submitted payload. Some fields of the Schema cannot be updated. These fields are listed below.  * id * name * created * modified  Any attempt to modify these fields will result in an error response with a status code of 400.  > `id` must remain in the request body, but it cannot be changed.  If `id` is omitted from the request body, the result will be a 400 error.
		         * @summary Update Source Schema (Full)
		         * @param {string} sourceId The Source id.
		         * @param {string} schemaId The Schema id.
		         * @param {Schema} schema
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putSourceSchema: function (sourceId, schemaId, schema, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.putSourceSchema(sourceId, schemaId, schema, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This end-point updates a list of provisioning policies on the specified source in IdentityNow. A token with API, or ORG_ADMIN authority is required to call this API.
		         * @summary Bulk Update Provisioning Policies
		         * @param {string} sourceId The Source id.
		         * @param {Array<ProvisioningPolicyDto>} provisioningPolicyDto
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateProvisioningPoliciesInBulk: function (sourceId, provisioningPolicyDto, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.updateProvisioningPoliciesInBulk(sourceId, provisioningPolicyDto, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API selectively updates an existing Provisioning Policy using a JSONPatch payload. Transforms can be used in the provisioning policy to create a new attribute that you only need during provisioning. Refer to [Transforms in Provisioning Policies](https://developer.sailpoint.com/idn/docs/transforms/guides/transforms-in-provisioning-policies) for more information. A token with API, ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		         * @summary Partial update of Provisioning Policy
		         * @param {string} sourceId The Source id.
		         * @param {UsageType} usageType The type of provisioning policy usage.  In IdentityNow, a source can support various provisioning operations. For example, when a joiner is added to a source, this may trigger both CREATE and UPDATE provisioning operations.  Each usage type is considered a provisioning policy.  A source can have any number of these provisioning policies defined.  These are the common usage types:  CREATE - This usage type relates to \&#39;Create Account Profile\&#39;, the provisioning template for the account to be created. For example, this would be used for a joiner on a source.   UPDATE - This usage type relates to \&#39;Update Account Profile\&#39;, the provisioning template for the \&#39;Update\&#39; connector operations. For example, this would be used for an attribute sync on a source. ENABLE - This usage type relates to \&#39;Enable Account Profile\&#39;, the provisioning template for the account to be enabled. For example, this could be used for a joiner on a source once the joiner\&#39;s account is created.  DISABLE - This usage type relates to \&#39;Disable Account Profile\&#39;, the provisioning template for the account to be disabled. For example, this could be used when a leaver is removed temporarily from a source.  You can use these four usage types for all your provisioning policy needs.
		         * @param {Array<JsonPatchOperation>} jsonPatchOperation The JSONPatch payload used to update the schema.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateProvisioningPolicy: function (sourceId, usageType, jsonPatchOperation, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.updateProvisioningPolicy(sourceId, usageType, jsonPatchOperation, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API partially updates a source in IdentityNow, using a list of patch operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.  Some fields are immutable and cannot be changed, such as:  * id * type * authoritative * created * modified * connector * connectorClass * passwordPolicies  Attempts to modify these fields will result in a 400 error.  A token with ORG_ADMIN, SOURCE_ADMIN, SOURCE_SUBADMIN, or API authority is required to call this API.
		         * @summary Update Source (Partial)
		         * @param {string} id The Source id
		         * @param {Array<JsonPatchOperation>} jsonPatchOperation A list of account update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard. Any password changes are submitted as plain-text and encrypted upon receipt in IdentityNow.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateSource: function (id, jsonPatchOperation, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.updateSource(id, jsonPatchOperation, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Use this API to selectively update an existing Schema using a JSONPatch payload.   The following schema fields are immutable and cannot be updated:  - id - name - created - modified   To switch an account attribute to a group entitlement, you need to have the following in place:  - `isEntitlement: true` - Must define a schema for the group and [add it to the source](https://developer.sailpoint.com/idn/api/v3/create-source-schema) before updating the `isGroup` flag.  For example, here is the `group` account attribute referencing a schema that defines the group: ```json {     \"name\": \"groups\",     \"type\": \"STRING\",     \"schema\": {         \"type\": \"CONNECTOR_SCHEMA\",         \"id\": \"2c9180887671ff8c01767b4671fc7d60\",         \"name\": \"group\"     },     \"description\": \"The groups, roles etc. that reference account group objects\",     \"isMulti\": true,     \"isEntitlement\": true,     \"isGroup\": true } ```
		         * @summary Update Source Schema (Partial)
		         * @param {string} sourceId The Source id.
		         * @param {string} schemaId The Schema id.
		         * @param {Array<JsonPatchOperation>} jsonPatchOperation The JSONPatch payload used to update the schema.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateSourceSchema: function (sourceId, schemaId, jsonPatchOperation, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.updateSourceSchema(sourceId, schemaId, jsonPatchOperation, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.SourcesApiFp = SourcesApiFp;
		/**
		 * SourcesApi - factory interface
		 * @export
		 */
		var SourcesApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.SourcesApiFp)(configuration);
		    return {
		        /**
		         * This API generates a create policy/template based on field value transforms. This API is intended for use when setting up JDBC Provisioning type sources, but it will also work on other source types. Transforms can be used in the provisioning policy to create a new attribute that you only need during provisioning. Refer to [Transforms in Provisioning Policies](https://developer.sailpoint.com/idn/docs/transforms/guides/transforms-in-provisioning-policies) for more information. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Create Provisioning Policy
		         * @param {string} sourceId The Source id
		         * @param {ProvisioningPolicyDto} provisioningPolicyDto
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createProvisioningPolicy: function (sourceId, provisioningPolicyDto, axiosOptions) {
		            return localVarFp.createProvisioningPolicy(sourceId, provisioningPolicyDto, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This creates a specific source with a full source JSON representation. Any passwords are submitted as plain-text and encrypted upon receipt in IdentityNow. A token with ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		         * @summary Creates a source in IdentityNow.
		         * @param {Source} source
		         * @param {boolean} [provisionAsCsv] If this parameter is &#x60;true&#x60;, it configures the source as a Delimited File (CSV) source. Setting this to &#x60;true&#x60; will automatically set the &#x60;type&#x60; of the source to &#x60;DelimitedFile&#x60;.  You must use this query parameter to create a Delimited File source as you would in the UI.  If you don\&#39;t set this query parameter and you attempt to set the &#x60;type&#x60; attribute directly, the request won\&#39;t correctly generate the source.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createSource: function (source, provisionAsCsv, axiosOptions) {
		            return localVarFp.createSource(source, provisionAsCsv, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Creates a new Schema on the specified Source in IdentityNow.
		         * @summary Create Schema on a Source
		         * @param {string} sourceId The Source id.
		         * @param {Schema} schema
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createSourceSchema: function (sourceId, schema, axiosOptions) {
		            return localVarFp.createSourceSchema(sourceId, schema, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Deletes the provisioning policy with the specified usage on an application. A token with API, or ORG_ADMIN authority is required to call this API.
		         * @summary Delete Provisioning Policy by UsageType
		         * @param {string} sourceId The Source ID.
		         * @param {UsageType} usageType The type of provisioning policy usage.  In IdentityNow, a source can support various provisioning operations. For example, when a joiner is added to a source, this may trigger both CREATE and UPDATE provisioning operations.  Each usage type is considered a provisioning policy.  A source can have any number of these provisioning policies defined.  These are the common usage types:  CREATE - This usage type relates to \&#39;Create Account Profile\&#39;, the provisioning template for the account to be created. For example, this would be used for a joiner on a source.   UPDATE - This usage type relates to \&#39;Update Account Profile\&#39;, the provisioning template for the \&#39;Update\&#39; connector operations. For example, this would be used for an attribute sync on a source. ENABLE - This usage type relates to \&#39;Enable Account Profile\&#39;, the provisioning template for the account to be enabled. For example, this could be used for a joiner on a source once the joiner\&#39;s account is created.  DISABLE - This usage type relates to \&#39;Disable Account Profile\&#39;, the provisioning template for the account to be disabled. For example, this could be used when a leaver is removed temporarily from a source.  You can use these four usage types for all your provisioning policy needs.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteProvisioningPolicy: function (sourceId, usageType, axiosOptions) {
		            return localVarFp.deleteProvisioningPolicy(sourceId, usageType, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This end-point deletes a specific source in IdentityNow. A token with ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API. All of accounts on the source will be removed first, then the source will be deleted. Actual status of task execution can be retrieved via method GET `/task-status/{id}`
		         * @summary Delete Source by ID
		         * @param {string} id The Source id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteSource: function (id, axiosOptions) {
		            return localVarFp.deleteSource(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         *
		         * @summary Delete Source Schema by ID
		         * @param {string} sourceId The Source id.
		         * @param {string} schemaId The Schema id.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteSourceSchema: function (sourceId, schemaId, axiosOptions) {
		            return localVarFp.deleteSourceSchema(sourceId, schemaId, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API downloads the CSV schema that defines the account attributes on a source. >**NOTE: This API is designated only for Delimited File sources.**
		         * @summary Downloads source accounts schema template
		         * @param {string} id The Source id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getAccountsSchema: function (id, axiosOptions) {
		            return localVarFp.getAccountsSchema(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API downloads the CSV schema that defines the entitlement attributes on a source.  >**NOTE: This API is designated only for Delimited File sources.**
		         * @summary Downloads source entitlements schema template
		         * @param {string} id The Source id
		         * @param {string} [schemaName] Name of entitlement schema
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getEntitlementsSchema: function (id, schemaName, axiosOptions) {
		            return localVarFp.getEntitlementsSchema(id, schemaName, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This end-point retrieves the ProvisioningPolicy with the specified usage on the specified Source in IdentityNow. A token with API, ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		         * @summary Get Provisioning Policy by UsageType
		         * @param {string} sourceId The Source ID.
		         * @param {UsageType} usageType The type of provisioning policy usage.  In IdentityNow, a source can support various provisioning operations. For example, when a joiner is added to a source, this may trigger both CREATE and UPDATE provisioning operations.  Each usage type is considered a provisioning policy.  A source can have any number of these provisioning policies defined.  These are the common usage types:  CREATE - This usage type relates to \&#39;Create Account Profile\&#39;, the provisioning template for the account to be created. For example, this would be used for a joiner on a source.   UPDATE - This usage type relates to \&#39;Update Account Profile\&#39;, the provisioning template for the \&#39;Update\&#39; connector operations. For example, this would be used for an attribute sync on a source. ENABLE - This usage type relates to \&#39;Enable Account Profile\&#39;, the provisioning template for the account to be enabled. For example, this could be used for a joiner on a source once the joiner\&#39;s account is created.  DISABLE - This usage type relates to \&#39;Disable Account Profile\&#39;, the provisioning template for the account to be disabled. For example, this could be used when a leaver is removed temporarily from a source.  You can use these four usage types for all your provisioning policy needs.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getProvisioningPolicy: function (sourceId, usageType, axiosOptions) {
		            return localVarFp.getProvisioningPolicy(sourceId, usageType, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This end-point gets a specific source in IdentityNow. A token with ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		         * @summary Get Source by ID
		         * @param {string} id The Source id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getSource: function (id, axiosOptions) {
		            return localVarFp.getSource(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This endpoint fetches source health by source\'s id
		         * @summary Fetches source health by id
		         * @param {string} sourceId The Source id.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getSourceHealth: function (sourceId, axiosOptions) {
		            return localVarFp.getSourceHealth(sourceId, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Get the Source Schema by ID in IdentityNow.
		         * @summary Get Source Schema by ID
		         * @param {string} sourceId The Source id.
		         * @param {string} schemaId The Schema id.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getSourceSchema: function (sourceId, schemaId, axiosOptions) {
		            return localVarFp.getSourceSchema(sourceId, schemaId, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API uploads a source schema template file to configure a source\'s account attributes.  To retrieve the file to modify and upload, log into Identity Now.   Click **Admin** -> **Connections** -> **Sources** -> **`{SourceName}`** -> **Import Data** -> **Account Schema** -> **Options** -> **Download Schema**  >**NOTE: This API is designated only for Delimited File sources.**
		         * @summary Uploads source accounts schema template
		         * @param {string} id The Source id
		         * @param {any} [file]
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        importAccountsSchema: function (id, file, axiosOptions) {
		            return localVarFp.importAccountsSchema(id, file, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This uploads a supplemental source connector file (like jdbc driver jars) to a source\'s S3 bucket. This also sends ETS and Audit events. A token with ORG_ADMIN authority is required to call this API.
		         * @summary Upload connector file to source
		         * @param {string} sourceId The Source id.
		         * @param {any} [file]
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        importConnectorFile: function (sourceId, file, axiosOptions) {
		            return localVarFp.importConnectorFile(sourceId, file, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API uploads a source schema template file to configure a source\'s entitlement attributes.  To retrieve the file to modify and upload, log into Identity Now.   Click **Admin** -> **Connections** -> **Sources** -> **`{SourceName}`** -> **Import Data** -> **Import Entitlements** -> **Download**  >**NOTE: This API is designated only for Delimited File sources.**
		         * @summary Uploads source entitlements schema template
		         * @param {string} id The Source id
		         * @param {string} [schemaName] Name of entitlement schema
		         * @param {any} [file]
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        importEntitlementsSchema: function (id, schemaName, file, axiosOptions) {
		            return localVarFp.importEntitlementsSchema(id, schemaName, file, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This end-point lists all the ProvisioningPolicies in IdentityNow. A token with API, or ORG_ADMIN authority is required to call this API.
		         * @summary Lists ProvisioningPolicies
		         * @param {string} sourceId The Source id
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listProvisioningPolicies: function (sourceId, axiosOptions) {
		            return localVarFp.listProvisioningPolicies(sourceId, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Lists the Schemas that exist on the specified Source in IdentityNow.
		         * @summary List Schemas on a Source
		         * @param {string} sourceId The Source ID.
		         * @param {string} [includeTypes] If set to \&#39;group\&#39;, then the account schema is filtered and only group schemas are returned. Only a value of \&#39;group\&#39; is recognized.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listSourceSchemas: function (sourceId, includeTypes, axiosOptions) {
		            return localVarFp.listSourceSchemas(sourceId, includeTypes, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This end-point lists all the sources in IdentityNow. A token with ORG_ADMIN, SOURCE_ADMIN, SOURCE_SUBADMIN, or ROLE_SUBADMIN authority is required to call this API.
		         * @summary Lists all sources in IdentityNow.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in, ge, gt, le, lt, ne, isnull, sw*  **name**: *co, eq, in, sw, ge, gt, ne, isnull*  **type**: *eq, in, ge, gt, ne, isnull, sw*  **owner.id**: *eq, in, ge, gt, le, lt, ne, isnull, sw*  **features**: *ca, co*  **created**: *eq, ge, gt, in, le, lt, ne, isnull, sw*  **modified**: *eq, ge, gt, in, le, lt, ne, isnull, sw*  **managementWorkgroup.id**: *eq, ge, gt, in, le, lt, ne, isnull, sw*  **description**: *eq, sw*  **authoritative**: *eq, ne, isnull*  **healthy**: *isnull*  **status**: *eq, in, ge, gt, le, lt, ne, isnull, sw*  **connectionType**: *eq, ge, gt, in, le, lt, ne, isnull, sw*  **connectorName**: *eq, ge, gt, in, ne, isnull, sw*
		         * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results)  Sorting is supported for the following fields: **type, created, modified, name, owner.name, healthy, status, id, description, owner.id, accountCorrelationConfig.id, accountCorrelationConfig.name, managerCorrelationRule.type, managerCorrelationRule.id, managerCorrelationRule.name, authoritative, managementWorkgroup.id, connectorName, connectionType**
		         * @param {string} [forSubadmin] Filter the returned list of sources for the identity specified by the parameter, which is the id of an identity with the role SOURCE_SUBADMIN. By convention, the value **me** indicates the identity id of the current user. Subadmins may only view Sources which they are able to administer; all other Sources will be filtered out when this parameter is set. If the current user is a SOURCE_SUBADMIN but fails to pass a valid value for this parameter, a 403 Forbidden is returned.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listSources: function (limit, offset, count, filters, sorters, forSubadmin, axiosOptions) {
		            return localVarFp.listSources(limit, offset, count, filters, sorters, forSubadmin, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This end-point updates the provisioning policy with the specified usage on the specified source in IdentityNow. Transforms can be used in the provisioning policy to create a new attribute that you only need during provisioning. Refer to [Transforms in Provisioning Policies](https://developer.sailpoint.com/idn/docs/transforms/guides/transforms-in-provisioning-policies) for more information. A token with API, ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		         * @summary Update Provisioning Policy by UsageType
		         * @param {string} sourceId The Source ID.
		         * @param {UsageType} usageType The type of provisioning policy usage.  In IdentityNow, a source can support various provisioning operations. For example, when a joiner is added to a source, this may trigger both CREATE and UPDATE provisioning operations.  Each usage type is considered a provisioning policy.  A source can have any number of these provisioning policies defined.  These are the common usage types:  CREATE - This usage type relates to \&#39;Create Account Profile\&#39;, the provisioning template for the account to be created. For example, this would be used for a joiner on a source.   UPDATE - This usage type relates to \&#39;Update Account Profile\&#39;, the provisioning template for the \&#39;Update\&#39; connector operations. For example, this would be used for an attribute sync on a source. ENABLE - This usage type relates to \&#39;Enable Account Profile\&#39;, the provisioning template for the account to be enabled. For example, this could be used for a joiner on a source once the joiner\&#39;s account is created.  DISABLE - This usage type relates to \&#39;Disable Account Profile\&#39;, the provisioning template for the account to be disabled. For example, this could be used when a leaver is removed temporarily from a source.  You can use these four usage types for all your provisioning policy needs.
		         * @param {ProvisioningPolicyDto} provisioningPolicyDto
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putProvisioningPolicy: function (sourceId, usageType, provisioningPolicyDto, axiosOptions) {
		            return localVarFp.putProvisioningPolicy(sourceId, usageType, provisioningPolicyDto, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API updates a source in IdentityNow, using a full object representation. In other words, the existing Source configuration is completely replaced.  Some fields are immutable and cannot be changed, such as:  * id * type * authoritative * connector * connectorClass * passwordPolicies  Attempts to modify these fields will result in a 400 error.  A token with ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		         * @summary Update Source (Full)
		         * @param {string} id The Source id
		         * @param {Source} source
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putSource: function (id, source, axiosOptions) {
		            return localVarFp.putSource(id, source, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API will completely replace an existing Schema with the submitted payload. Some fields of the Schema cannot be updated. These fields are listed below.  * id * name * created * modified  Any attempt to modify these fields will result in an error response with a status code of 400.  > `id` must remain in the request body, but it cannot be changed.  If `id` is omitted from the request body, the result will be a 400 error.
		         * @summary Update Source Schema (Full)
		         * @param {string} sourceId The Source id.
		         * @param {string} schemaId The Schema id.
		         * @param {Schema} schema
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putSourceSchema: function (sourceId, schemaId, schema, axiosOptions) {
		            return localVarFp.putSourceSchema(sourceId, schemaId, schema, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This end-point updates a list of provisioning policies on the specified source in IdentityNow. A token with API, or ORG_ADMIN authority is required to call this API.
		         * @summary Bulk Update Provisioning Policies
		         * @param {string} sourceId The Source id.
		         * @param {Array<ProvisioningPolicyDto>} provisioningPolicyDto
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateProvisioningPoliciesInBulk: function (sourceId, provisioningPolicyDto, axiosOptions) {
		            return localVarFp.updateProvisioningPoliciesInBulk(sourceId, provisioningPolicyDto, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API selectively updates an existing Provisioning Policy using a JSONPatch payload. Transforms can be used in the provisioning policy to create a new attribute that you only need during provisioning. Refer to [Transforms in Provisioning Policies](https://developer.sailpoint.com/idn/docs/transforms/guides/transforms-in-provisioning-policies) for more information. A token with API, ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		         * @summary Partial update of Provisioning Policy
		         * @param {string} sourceId The Source id.
		         * @param {UsageType} usageType The type of provisioning policy usage.  In IdentityNow, a source can support various provisioning operations. For example, when a joiner is added to a source, this may trigger both CREATE and UPDATE provisioning operations.  Each usage type is considered a provisioning policy.  A source can have any number of these provisioning policies defined.  These are the common usage types:  CREATE - This usage type relates to \&#39;Create Account Profile\&#39;, the provisioning template for the account to be created. For example, this would be used for a joiner on a source.   UPDATE - This usage type relates to \&#39;Update Account Profile\&#39;, the provisioning template for the \&#39;Update\&#39; connector operations. For example, this would be used for an attribute sync on a source. ENABLE - This usage type relates to \&#39;Enable Account Profile\&#39;, the provisioning template for the account to be enabled. For example, this could be used for a joiner on a source once the joiner\&#39;s account is created.  DISABLE - This usage type relates to \&#39;Disable Account Profile\&#39;, the provisioning template for the account to be disabled. For example, this could be used when a leaver is removed temporarily from a source.  You can use these four usage types for all your provisioning policy needs.
		         * @param {Array<JsonPatchOperation>} jsonPatchOperation The JSONPatch payload used to update the schema.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateProvisioningPolicy: function (sourceId, usageType, jsonPatchOperation, axiosOptions) {
		            return localVarFp.updateProvisioningPolicy(sourceId, usageType, jsonPatchOperation, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API partially updates a source in IdentityNow, using a list of patch operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.  Some fields are immutable and cannot be changed, such as:  * id * type * authoritative * created * modified * connector * connectorClass * passwordPolicies  Attempts to modify these fields will result in a 400 error.  A token with ORG_ADMIN, SOURCE_ADMIN, SOURCE_SUBADMIN, or API authority is required to call this API.
		         * @summary Update Source (Partial)
		         * @param {string} id The Source id
		         * @param {Array<JsonPatchOperation>} jsonPatchOperation A list of account update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard. Any password changes are submitted as plain-text and encrypted upon receipt in IdentityNow.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateSource: function (id, jsonPatchOperation, axiosOptions) {
		            return localVarFp.updateSource(id, jsonPatchOperation, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Use this API to selectively update an existing Schema using a JSONPatch payload.   The following schema fields are immutable and cannot be updated:  - id - name - created - modified   To switch an account attribute to a group entitlement, you need to have the following in place:  - `isEntitlement: true` - Must define a schema for the group and [add it to the source](https://developer.sailpoint.com/idn/api/v3/create-source-schema) before updating the `isGroup` flag.  For example, here is the `group` account attribute referencing a schema that defines the group: ```json {     \"name\": \"groups\",     \"type\": \"STRING\",     \"schema\": {         \"type\": \"CONNECTOR_SCHEMA\",         \"id\": \"2c9180887671ff8c01767b4671fc7d60\",         \"name\": \"group\"     },     \"description\": \"The groups, roles etc. that reference account group objects\",     \"isMulti\": true,     \"isEntitlement\": true,     \"isGroup\": true } ```
		         * @summary Update Source Schema (Partial)
		         * @param {string} sourceId The Source id.
		         * @param {string} schemaId The Schema id.
		         * @param {Array<JsonPatchOperation>} jsonPatchOperation The JSONPatch payload used to update the schema.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateSourceSchema: function (sourceId, schemaId, jsonPatchOperation, axiosOptions) {
		            return localVarFp.updateSourceSchema(sourceId, schemaId, jsonPatchOperation, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.SourcesApiFactory = SourcesApiFactory;
		/**
		 * SourcesApi - object-oriented interface
		 * @export
		 * @class SourcesApi
		 * @extends {BaseAPI}
		 */
		var SourcesApi = /** @class */ (function (_super) {
		    __extends(SourcesApi, _super);
		    function SourcesApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * This API generates a create policy/template based on field value transforms. This API is intended for use when setting up JDBC Provisioning type sources, but it will also work on other source types. Transforms can be used in the provisioning policy to create a new attribute that you only need during provisioning. Refer to [Transforms in Provisioning Policies](https://developer.sailpoint.com/idn/docs/transforms/guides/transforms-in-provisioning-policies) for more information. A token with ORG_ADMIN authority is required to call this API.
		     * @summary Create Provisioning Policy
		     * @param {SourcesApiCreateProvisioningPolicyRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SourcesApi
		     */
		    SourcesApi.prototype.createProvisioningPolicy = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SourcesApiFp)(this.configuration).createProvisioningPolicy(requestParameters.sourceId, requestParameters.provisioningPolicyDto, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This creates a specific source with a full source JSON representation. Any passwords are submitted as plain-text and encrypted upon receipt in IdentityNow. A token with ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		     * @summary Creates a source in IdentityNow.
		     * @param {SourcesApiCreateSourceRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SourcesApi
		     */
		    SourcesApi.prototype.createSource = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SourcesApiFp)(this.configuration).createSource(requestParameters.source, requestParameters.provisionAsCsv, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Creates a new Schema on the specified Source in IdentityNow.
		     * @summary Create Schema on a Source
		     * @param {SourcesApiCreateSourceSchemaRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SourcesApi
		     */
		    SourcesApi.prototype.createSourceSchema = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SourcesApiFp)(this.configuration).createSourceSchema(requestParameters.sourceId, requestParameters.schema, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Deletes the provisioning policy with the specified usage on an application. A token with API, or ORG_ADMIN authority is required to call this API.
		     * @summary Delete Provisioning Policy by UsageType
		     * @param {SourcesApiDeleteProvisioningPolicyRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SourcesApi
		     */
		    SourcesApi.prototype.deleteProvisioningPolicy = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SourcesApiFp)(this.configuration).deleteProvisioningPolicy(requestParameters.sourceId, requestParameters.usageType, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This end-point deletes a specific source in IdentityNow. A token with ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API. All of accounts on the source will be removed first, then the source will be deleted. Actual status of task execution can be retrieved via method GET `/task-status/{id}`
		     * @summary Delete Source by ID
		     * @param {SourcesApiDeleteSourceRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SourcesApi
		     */
		    SourcesApi.prototype.deleteSource = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SourcesApiFp)(this.configuration).deleteSource(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     *
		     * @summary Delete Source Schema by ID
		     * @param {SourcesApiDeleteSourceSchemaRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SourcesApi
		     */
		    SourcesApi.prototype.deleteSourceSchema = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SourcesApiFp)(this.configuration).deleteSourceSchema(requestParameters.sourceId, requestParameters.schemaId, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API downloads the CSV schema that defines the account attributes on a source. >**NOTE: This API is designated only for Delimited File sources.**
		     * @summary Downloads source accounts schema template
		     * @param {SourcesApiGetAccountsSchemaRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SourcesApi
		     */
		    SourcesApi.prototype.getAccountsSchema = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SourcesApiFp)(this.configuration).getAccountsSchema(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API downloads the CSV schema that defines the entitlement attributes on a source.  >**NOTE: This API is designated only for Delimited File sources.**
		     * @summary Downloads source entitlements schema template
		     * @param {SourcesApiGetEntitlementsSchemaRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SourcesApi
		     */
		    SourcesApi.prototype.getEntitlementsSchema = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SourcesApiFp)(this.configuration).getEntitlementsSchema(requestParameters.id, requestParameters.schemaName, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This end-point retrieves the ProvisioningPolicy with the specified usage on the specified Source in IdentityNow. A token with API, ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		     * @summary Get Provisioning Policy by UsageType
		     * @param {SourcesApiGetProvisioningPolicyRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SourcesApi
		     */
		    SourcesApi.prototype.getProvisioningPolicy = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SourcesApiFp)(this.configuration).getProvisioningPolicy(requestParameters.sourceId, requestParameters.usageType, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This end-point gets a specific source in IdentityNow. A token with ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		     * @summary Get Source by ID
		     * @param {SourcesApiGetSourceRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SourcesApi
		     */
		    SourcesApi.prototype.getSource = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SourcesApiFp)(this.configuration).getSource(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This endpoint fetches source health by source\'s id
		     * @summary Fetches source health by id
		     * @param {SourcesApiGetSourceHealthRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SourcesApi
		     */
		    SourcesApi.prototype.getSourceHealth = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SourcesApiFp)(this.configuration).getSourceHealth(requestParameters.sourceId, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Get the Source Schema by ID in IdentityNow.
		     * @summary Get Source Schema by ID
		     * @param {SourcesApiGetSourceSchemaRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SourcesApi
		     */
		    SourcesApi.prototype.getSourceSchema = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SourcesApiFp)(this.configuration).getSourceSchema(requestParameters.sourceId, requestParameters.schemaId, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API uploads a source schema template file to configure a source\'s account attributes.  To retrieve the file to modify and upload, log into Identity Now.   Click **Admin** -> **Connections** -> **Sources** -> **`{SourceName}`** -> **Import Data** -> **Account Schema** -> **Options** -> **Download Schema**  >**NOTE: This API is designated only for Delimited File sources.**
		     * @summary Uploads source accounts schema template
		     * @param {SourcesApiImportAccountsSchemaRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SourcesApi
		     */
		    SourcesApi.prototype.importAccountsSchema = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SourcesApiFp)(this.configuration).importAccountsSchema(requestParameters.id, requestParameters.file, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This uploads a supplemental source connector file (like jdbc driver jars) to a source\'s S3 bucket. This also sends ETS and Audit events. A token with ORG_ADMIN authority is required to call this API.
		     * @summary Upload connector file to source
		     * @param {SourcesApiImportConnectorFileRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SourcesApi
		     */
		    SourcesApi.prototype.importConnectorFile = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SourcesApiFp)(this.configuration).importConnectorFile(requestParameters.sourceId, requestParameters.file, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API uploads a source schema template file to configure a source\'s entitlement attributes.  To retrieve the file to modify and upload, log into Identity Now.   Click **Admin** -> **Connections** -> **Sources** -> **`{SourceName}`** -> **Import Data** -> **Import Entitlements** -> **Download**  >**NOTE: This API is designated only for Delimited File sources.**
		     * @summary Uploads source entitlements schema template
		     * @param {SourcesApiImportEntitlementsSchemaRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SourcesApi
		     */
		    SourcesApi.prototype.importEntitlementsSchema = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SourcesApiFp)(this.configuration).importEntitlementsSchema(requestParameters.id, requestParameters.schemaName, requestParameters.file, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This end-point lists all the ProvisioningPolicies in IdentityNow. A token with API, or ORG_ADMIN authority is required to call this API.
		     * @summary Lists ProvisioningPolicies
		     * @param {SourcesApiListProvisioningPoliciesRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SourcesApi
		     */
		    SourcesApi.prototype.listProvisioningPolicies = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SourcesApiFp)(this.configuration).listProvisioningPolicies(requestParameters.sourceId, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Lists the Schemas that exist on the specified Source in IdentityNow.
		     * @summary List Schemas on a Source
		     * @param {SourcesApiListSourceSchemasRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SourcesApi
		     */
		    SourcesApi.prototype.listSourceSchemas = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SourcesApiFp)(this.configuration).listSourceSchemas(requestParameters.sourceId, requestParameters.includeTypes, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This end-point lists all the sources in IdentityNow. A token with ORG_ADMIN, SOURCE_ADMIN, SOURCE_SUBADMIN, or ROLE_SUBADMIN authority is required to call this API.
		     * @summary Lists all sources in IdentityNow.
		     * @param {SourcesApiListSourcesRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SourcesApi
		     */
		    SourcesApi.prototype.listSources = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.SourcesApiFp)(this.configuration).listSources(requestParameters.limit, requestParameters.offset, requestParameters.count, requestParameters.filters, requestParameters.sorters, requestParameters.forSubadmin, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This end-point updates the provisioning policy with the specified usage on the specified source in IdentityNow. Transforms can be used in the provisioning policy to create a new attribute that you only need during provisioning. Refer to [Transforms in Provisioning Policies](https://developer.sailpoint.com/idn/docs/transforms/guides/transforms-in-provisioning-policies) for more information. A token with API, ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		     * @summary Update Provisioning Policy by UsageType
		     * @param {SourcesApiPutProvisioningPolicyRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SourcesApi
		     */
		    SourcesApi.prototype.putProvisioningPolicy = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SourcesApiFp)(this.configuration).putProvisioningPolicy(requestParameters.sourceId, requestParameters.usageType, requestParameters.provisioningPolicyDto, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API updates a source in IdentityNow, using a full object representation. In other words, the existing Source configuration is completely replaced.  Some fields are immutable and cannot be changed, such as:  * id * type * authoritative * connector * connectorClass * passwordPolicies  Attempts to modify these fields will result in a 400 error.  A token with ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		     * @summary Update Source (Full)
		     * @param {SourcesApiPutSourceRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SourcesApi
		     */
		    SourcesApi.prototype.putSource = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SourcesApiFp)(this.configuration).putSource(requestParameters.id, requestParameters.source, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API will completely replace an existing Schema with the submitted payload. Some fields of the Schema cannot be updated. These fields are listed below.  * id * name * created * modified  Any attempt to modify these fields will result in an error response with a status code of 400.  > `id` must remain in the request body, but it cannot be changed.  If `id` is omitted from the request body, the result will be a 400 error.
		     * @summary Update Source Schema (Full)
		     * @param {SourcesApiPutSourceSchemaRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SourcesApi
		     */
		    SourcesApi.prototype.putSourceSchema = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SourcesApiFp)(this.configuration).putSourceSchema(requestParameters.sourceId, requestParameters.schemaId, requestParameters.schema, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This end-point updates a list of provisioning policies on the specified source in IdentityNow. A token with API, or ORG_ADMIN authority is required to call this API.
		     * @summary Bulk Update Provisioning Policies
		     * @param {SourcesApiUpdateProvisioningPoliciesInBulkRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SourcesApi
		     */
		    SourcesApi.prototype.updateProvisioningPoliciesInBulk = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SourcesApiFp)(this.configuration).updateProvisioningPoliciesInBulk(requestParameters.sourceId, requestParameters.provisioningPolicyDto, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API selectively updates an existing Provisioning Policy using a JSONPatch payload. Transforms can be used in the provisioning policy to create a new attribute that you only need during provisioning. Refer to [Transforms in Provisioning Policies](https://developer.sailpoint.com/idn/docs/transforms/guides/transforms-in-provisioning-policies) for more information. A token with API, ORG_ADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		     * @summary Partial update of Provisioning Policy
		     * @param {SourcesApiUpdateProvisioningPolicyRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SourcesApi
		     */
		    SourcesApi.prototype.updateProvisioningPolicy = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SourcesApiFp)(this.configuration).updateProvisioningPolicy(requestParameters.sourceId, requestParameters.usageType, requestParameters.jsonPatchOperation, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API partially updates a source in IdentityNow, using a list of patch operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.  Some fields are immutable and cannot be changed, such as:  * id * type * authoritative * created * modified * connector * connectorClass * passwordPolicies  Attempts to modify these fields will result in a 400 error.  A token with ORG_ADMIN, SOURCE_ADMIN, SOURCE_SUBADMIN, or API authority is required to call this API.
		     * @summary Update Source (Partial)
		     * @param {SourcesApiUpdateSourceRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SourcesApi
		     */
		    SourcesApi.prototype.updateSource = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SourcesApiFp)(this.configuration).updateSource(requestParameters.id, requestParameters.jsonPatchOperation, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Use this API to selectively update an existing Schema using a JSONPatch payload.   The following schema fields are immutable and cannot be updated:  - id - name - created - modified   To switch an account attribute to a group entitlement, you need to have the following in place:  - `isEntitlement: true` - Must define a schema for the group and [add it to the source](https://developer.sailpoint.com/idn/api/v3/create-source-schema) before updating the `isGroup` flag.  For example, here is the `group` account attribute referencing a schema that defines the group: ```json {     \"name\": \"groups\",     \"type\": \"STRING\",     \"schema\": {         \"type\": \"CONNECTOR_SCHEMA\",         \"id\": \"2c9180887671ff8c01767b4671fc7d60\",         \"name\": \"group\"     },     \"description\": \"The groups, roles etc. that reference account group objects\",     \"isMulti\": true,     \"isEntitlement\": true,     \"isGroup\": true } ```
		     * @summary Update Source Schema (Partial)
		     * @param {SourcesApiUpdateSourceSchemaRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof SourcesApi
		     */
		    SourcesApi.prototype.updateSourceSchema = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.SourcesApiFp)(this.configuration).updateSourceSchema(requestParameters.sourceId, requestParameters.schemaId, requestParameters.jsonPatchOperation, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return SourcesApi;
		}(base_1.BaseAPI));
		exports.SourcesApi = SourcesApi;
		/**
		 * TaggedObjectsApi - axios parameter creator
		 * @export
		 */
		var TaggedObjectsApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * This deletes a tagged object for the specified type.
		         * @summary Delete Tagged Object
		         * @param {'ACCESS_PROFILE' | 'APPLICATION' | 'CAMPAIGN' | 'ENTITLEMENT' | 'IDENTITY' | 'ROLE' | 'SOD_POLICY' | 'SOURCE'} type The type of tagged object to delete.
		         * @param {string} id The ID of the object reference to delete.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteTaggedObject: function (type, id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'type' is not null or undefined
		                            (0, common_1.assertParamExists)('deleteTaggedObject', 'type', type);
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('deleteTaggedObject', 'id', id);
		                            localVarPath = "/tagged-objects/{type}/{id}"
		                                .replace("{".concat("type", "}"), encodeURIComponent(String(type)))
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'DELETE' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API removes tags from multiple objects.  A token with API, CERT_ADMIN, ORG_ADMIN, REPORT_ADMIN, ROLE_ADMIN, ROLE_SUBADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		         * @summary Remove Tags from Multiple Objects
		         * @param {BulkTaggedObject} bulkTaggedObject Supported object types are ACCESS_PROFILE, APPLICATION, CAMPAIGN, ENTITLEMENT, IDENTITY, ROLE, SOD_POLICY, SOURCE.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteTagsToManyObject: function (bulkTaggedObject, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'bulkTaggedObject' is not null or undefined
		                            (0, common_1.assertParamExists)('deleteTagsToManyObject', 'bulkTaggedObject', bulkTaggedObject);
		                            localVarPath = "/tagged-objects/bulk-remove";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(bulkTaggedObject, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets a tagged object for the specified type.
		         * @summary Get Tagged Object
		         * @param {'ACCESS_PROFILE' | 'APPLICATION' | 'CAMPAIGN' | 'ENTITLEMENT' | 'IDENTITY' | 'ROLE' | 'SOD_POLICY' | 'SOURCE'} type The type of tagged object to retrieve.
		         * @param {string} id The ID of the object reference to retrieve.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getTaggedObject: function (type, id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'type' is not null or undefined
		                            (0, common_1.assertParamExists)('getTaggedObject', 'type', type);
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getTaggedObject', 'id', id);
		                            localVarPath = "/tagged-objects/{type}/{id}"
		                                .replace("{".concat("type", "}"), encodeURIComponent(String(type)))
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns a list of all tagged objects.  Any authenticated token may be used to call this API.
		         * @summary List Tagged Objects
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **objectRef.id**: *eq, in*  **objectRef.type**: *eq, in*  **tagName**: *eq, in*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listTaggedObjects: function (limit, offset, count, filters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/tagged-objects";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns a list of all tagged objects by type.  Any authenticated token may be used to call this API.
		         * @summary List Tagged Objects by Type
		         * @param {'ACCESS_PROFILE' | 'APPLICATION' | 'CAMPAIGN' | 'ENTITLEMENT' | 'IDENTITY' | 'ROLE' | 'SOD_POLICY' | 'SOURCE'} type The type of tagged object to retrieve.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **objectRef.id**: *eq*  **objectRef.type**: *eq*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listTaggedObjectsByType: function (type, limit, offset, count, filters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'type' is not null or undefined
		                            (0, common_1.assertParamExists)('listTaggedObjectsByType', 'type', type);
		                            localVarPath = "/tagged-objects/{type}"
		                                .replace("{".concat("type", "}"), encodeURIComponent(String(type)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This updates a tagged object for the specified type.
		         * @summary Update Tagged Object
		         * @param {'ACCESS_PROFILE' | 'APPLICATION' | 'CAMPAIGN' | 'ENTITLEMENT' | 'IDENTITY' | 'ROLE' | 'SOD_POLICY' | 'SOURCE'} type The type of tagged object to update.
		         * @param {string} id The ID of the object reference to update.
		         * @param {TaggedObject} taggedObject
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putTaggedObject: function (type, id, taggedObject, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'type' is not null or undefined
		                            (0, common_1.assertParamExists)('putTaggedObject', 'type', type);
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('putTaggedObject', 'id', id);
		                            // verify required parameter 'taggedObject' is not null or undefined
		                            (0, common_1.assertParamExists)('putTaggedObject', 'taggedObject', taggedObject);
		                            localVarPath = "/tagged-objects/{type}/{id}"
		                                .replace("{".concat("type", "}"), encodeURIComponent(String(type)))
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PUT' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(taggedObject, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This adds a tag to an object.  Any authenticated token may be used to call this API.
		         * @summary Add Tag to Object
		         * @param {TaggedObject} taggedObject
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        setTagToObject: function (taggedObject, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'taggedObject' is not null or undefined
		                            (0, common_1.assertParamExists)('setTagToObject', 'taggedObject', taggedObject);
		                            localVarPath = "/tagged-objects";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(taggedObject, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API adds tags to multiple objects.  A token with API, CERT_ADMIN, ORG_ADMIN, REPORT_ADMIN, ROLE_ADMIN, ROLE_SUBADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		         * @summary Tag Multiple Objects
		         * @param {BulkTaggedObject} bulkTaggedObject Supported object types are ACCESS_PROFILE, APPLICATION, CAMPAIGN, ENTITLEMENT, IDENTITY, ROLE, SOD_POLICY, SOURCE.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        setTagsToManyObjects: function (bulkTaggedObject, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'bulkTaggedObject' is not null or undefined
		                            (0, common_1.assertParamExists)('setTagsToManyObjects', 'bulkTaggedObject', bulkTaggedObject);
		                            localVarPath = "/tagged-objects/bulk-add";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(bulkTaggedObject, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.TaggedObjectsApiAxiosParamCreator = TaggedObjectsApiAxiosParamCreator;
		/**
		 * TaggedObjectsApi - functional programming interface
		 * @export
		 */
		var TaggedObjectsApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.TaggedObjectsApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * This deletes a tagged object for the specified type.
		         * @summary Delete Tagged Object
		         * @param {'ACCESS_PROFILE' | 'APPLICATION' | 'CAMPAIGN' | 'ENTITLEMENT' | 'IDENTITY' | 'ROLE' | 'SOD_POLICY' | 'SOURCE'} type The type of tagged object to delete.
		         * @param {string} id The ID of the object reference to delete.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteTaggedObject: function (type, id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.deleteTaggedObject(type, id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API removes tags from multiple objects.  A token with API, CERT_ADMIN, ORG_ADMIN, REPORT_ADMIN, ROLE_ADMIN, ROLE_SUBADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		         * @summary Remove Tags from Multiple Objects
		         * @param {BulkTaggedObject} bulkTaggedObject Supported object types are ACCESS_PROFILE, APPLICATION, CAMPAIGN, ENTITLEMENT, IDENTITY, ROLE, SOD_POLICY, SOURCE.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteTagsToManyObject: function (bulkTaggedObject, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.deleteTagsToManyObject(bulkTaggedObject, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets a tagged object for the specified type.
		         * @summary Get Tagged Object
		         * @param {'ACCESS_PROFILE' | 'APPLICATION' | 'CAMPAIGN' | 'ENTITLEMENT' | 'IDENTITY' | 'ROLE' | 'SOD_POLICY' | 'SOURCE'} type The type of tagged object to retrieve.
		         * @param {string} id The ID of the object reference to retrieve.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getTaggedObject: function (type, id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getTaggedObject(type, id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns a list of all tagged objects.  Any authenticated token may be used to call this API.
		         * @summary List Tagged Objects
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **objectRef.id**: *eq, in*  **objectRef.type**: *eq, in*  **tagName**: *eq, in*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listTaggedObjects: function (limit, offset, count, filters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listTaggedObjects(limit, offset, count, filters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns a list of all tagged objects by type.  Any authenticated token may be used to call this API.
		         * @summary List Tagged Objects by Type
		         * @param {'ACCESS_PROFILE' | 'APPLICATION' | 'CAMPAIGN' | 'ENTITLEMENT' | 'IDENTITY' | 'ROLE' | 'SOD_POLICY' | 'SOURCE'} type The type of tagged object to retrieve.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **objectRef.id**: *eq*  **objectRef.type**: *eq*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listTaggedObjectsByType: function (type, limit, offset, count, filters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listTaggedObjectsByType(type, limit, offset, count, filters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This updates a tagged object for the specified type.
		         * @summary Update Tagged Object
		         * @param {'ACCESS_PROFILE' | 'APPLICATION' | 'CAMPAIGN' | 'ENTITLEMENT' | 'IDENTITY' | 'ROLE' | 'SOD_POLICY' | 'SOURCE'} type The type of tagged object to update.
		         * @param {string} id The ID of the object reference to update.
		         * @param {TaggedObject} taggedObject
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putTaggedObject: function (type, id, taggedObject, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.putTaggedObject(type, id, taggedObject, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This adds a tag to an object.  Any authenticated token may be used to call this API.
		         * @summary Add Tag to Object
		         * @param {TaggedObject} taggedObject
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        setTagToObject: function (taggedObject, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.setTagToObject(taggedObject, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API adds tags to multiple objects.  A token with API, CERT_ADMIN, ORG_ADMIN, REPORT_ADMIN, ROLE_ADMIN, ROLE_SUBADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		         * @summary Tag Multiple Objects
		         * @param {BulkTaggedObject} bulkTaggedObject Supported object types are ACCESS_PROFILE, APPLICATION, CAMPAIGN, ENTITLEMENT, IDENTITY, ROLE, SOD_POLICY, SOURCE.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        setTagsToManyObjects: function (bulkTaggedObject, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.setTagsToManyObjects(bulkTaggedObject, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.TaggedObjectsApiFp = TaggedObjectsApiFp;
		/**
		 * TaggedObjectsApi - factory interface
		 * @export
		 */
		var TaggedObjectsApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.TaggedObjectsApiFp)(configuration);
		    return {
		        /**
		         * This deletes a tagged object for the specified type.
		         * @summary Delete Tagged Object
		         * @param {'ACCESS_PROFILE' | 'APPLICATION' | 'CAMPAIGN' | 'ENTITLEMENT' | 'IDENTITY' | 'ROLE' | 'SOD_POLICY' | 'SOURCE'} type The type of tagged object to delete.
		         * @param {string} id The ID of the object reference to delete.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteTaggedObject: function (type, id, axiosOptions) {
		            return localVarFp.deleteTaggedObject(type, id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API removes tags from multiple objects.  A token with API, CERT_ADMIN, ORG_ADMIN, REPORT_ADMIN, ROLE_ADMIN, ROLE_SUBADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		         * @summary Remove Tags from Multiple Objects
		         * @param {BulkTaggedObject} bulkTaggedObject Supported object types are ACCESS_PROFILE, APPLICATION, CAMPAIGN, ENTITLEMENT, IDENTITY, ROLE, SOD_POLICY, SOURCE.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteTagsToManyObject: function (bulkTaggedObject, axiosOptions) {
		            return localVarFp.deleteTagsToManyObject(bulkTaggedObject, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This gets a tagged object for the specified type.
		         * @summary Get Tagged Object
		         * @param {'ACCESS_PROFILE' | 'APPLICATION' | 'CAMPAIGN' | 'ENTITLEMENT' | 'IDENTITY' | 'ROLE' | 'SOD_POLICY' | 'SOURCE'} type The type of tagged object to retrieve.
		         * @param {string} id The ID of the object reference to retrieve.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getTaggedObject: function (type, id, axiosOptions) {
		            return localVarFp.getTaggedObject(type, id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API returns a list of all tagged objects.  Any authenticated token may be used to call this API.
		         * @summary List Tagged Objects
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **objectRef.id**: *eq, in*  **objectRef.type**: *eq, in*  **tagName**: *eq, in*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listTaggedObjects: function (limit, offset, count, filters, axiosOptions) {
		            return localVarFp.listTaggedObjects(limit, offset, count, filters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API returns a list of all tagged objects by type.  Any authenticated token may be used to call this API.
		         * @summary List Tagged Objects by Type
		         * @param {'ACCESS_PROFILE' | 'APPLICATION' | 'CAMPAIGN' | 'ENTITLEMENT' | 'IDENTITY' | 'ROLE' | 'SOD_POLICY' | 'SOURCE'} type The type of tagged object to retrieve.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **objectRef.id**: *eq*  **objectRef.type**: *eq*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listTaggedObjectsByType: function (type, limit, offset, count, filters, axiosOptions) {
		            return localVarFp.listTaggedObjectsByType(type, limit, offset, count, filters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This updates a tagged object for the specified type.
		         * @summary Update Tagged Object
		         * @param {'ACCESS_PROFILE' | 'APPLICATION' | 'CAMPAIGN' | 'ENTITLEMENT' | 'IDENTITY' | 'ROLE' | 'SOD_POLICY' | 'SOURCE'} type The type of tagged object to update.
		         * @param {string} id The ID of the object reference to update.
		         * @param {TaggedObject} taggedObject
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        putTaggedObject: function (type, id, taggedObject, axiosOptions) {
		            return localVarFp.putTaggedObject(type, id, taggedObject, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This adds a tag to an object.  Any authenticated token may be used to call this API.
		         * @summary Add Tag to Object
		         * @param {TaggedObject} taggedObject
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        setTagToObject: function (taggedObject, axiosOptions) {
		            return localVarFp.setTagToObject(taggedObject, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API adds tags to multiple objects.  A token with API, CERT_ADMIN, ORG_ADMIN, REPORT_ADMIN, ROLE_ADMIN, ROLE_SUBADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		         * @summary Tag Multiple Objects
		         * @param {BulkTaggedObject} bulkTaggedObject Supported object types are ACCESS_PROFILE, APPLICATION, CAMPAIGN, ENTITLEMENT, IDENTITY, ROLE, SOD_POLICY, SOURCE.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        setTagsToManyObjects: function (bulkTaggedObject, axiosOptions) {
		            return localVarFp.setTagsToManyObjects(bulkTaggedObject, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.TaggedObjectsApiFactory = TaggedObjectsApiFactory;
		/**
		 * TaggedObjectsApi - object-oriented interface
		 * @export
		 * @class TaggedObjectsApi
		 * @extends {BaseAPI}
		 */
		var TaggedObjectsApi = /** @class */ (function (_super) {
		    __extends(TaggedObjectsApi, _super);
		    function TaggedObjectsApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * This deletes a tagged object for the specified type.
		     * @summary Delete Tagged Object
		     * @param {TaggedObjectsApiDeleteTaggedObjectRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof TaggedObjectsApi
		     */
		    TaggedObjectsApi.prototype.deleteTaggedObject = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.TaggedObjectsApiFp)(this.configuration).deleteTaggedObject(requestParameters.type, requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API removes tags from multiple objects.  A token with API, CERT_ADMIN, ORG_ADMIN, REPORT_ADMIN, ROLE_ADMIN, ROLE_SUBADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		     * @summary Remove Tags from Multiple Objects
		     * @param {TaggedObjectsApiDeleteTagsToManyObjectRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof TaggedObjectsApi
		     */
		    TaggedObjectsApi.prototype.deleteTagsToManyObject = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.TaggedObjectsApiFp)(this.configuration).deleteTagsToManyObject(requestParameters.bulkTaggedObject, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This gets a tagged object for the specified type.
		     * @summary Get Tagged Object
		     * @param {TaggedObjectsApiGetTaggedObjectRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof TaggedObjectsApi
		     */
		    TaggedObjectsApi.prototype.getTaggedObject = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.TaggedObjectsApiFp)(this.configuration).getTaggedObject(requestParameters.type, requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API returns a list of all tagged objects.  Any authenticated token may be used to call this API.
		     * @summary List Tagged Objects
		     * @param {TaggedObjectsApiListTaggedObjectsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof TaggedObjectsApi
		     */
		    TaggedObjectsApi.prototype.listTaggedObjects = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.TaggedObjectsApiFp)(this.configuration).listTaggedObjects(requestParameters.limit, requestParameters.offset, requestParameters.count, requestParameters.filters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API returns a list of all tagged objects by type.  Any authenticated token may be used to call this API.
		     * @summary List Tagged Objects by Type
		     * @param {TaggedObjectsApiListTaggedObjectsByTypeRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof TaggedObjectsApi
		     */
		    TaggedObjectsApi.prototype.listTaggedObjectsByType = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.TaggedObjectsApiFp)(this.configuration).listTaggedObjectsByType(requestParameters.type, requestParameters.limit, requestParameters.offset, requestParameters.count, requestParameters.filters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This updates a tagged object for the specified type.
		     * @summary Update Tagged Object
		     * @param {TaggedObjectsApiPutTaggedObjectRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof TaggedObjectsApi
		     */
		    TaggedObjectsApi.prototype.putTaggedObject = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.TaggedObjectsApiFp)(this.configuration).putTaggedObject(requestParameters.type, requestParameters.id, requestParameters.taggedObject, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This adds a tag to an object.  Any authenticated token may be used to call this API.
		     * @summary Add Tag to Object
		     * @param {TaggedObjectsApiSetTagToObjectRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof TaggedObjectsApi
		     */
		    TaggedObjectsApi.prototype.setTagToObject = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.TaggedObjectsApiFp)(this.configuration).setTagToObject(requestParameters.taggedObject, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API adds tags to multiple objects.  A token with API, CERT_ADMIN, ORG_ADMIN, REPORT_ADMIN, ROLE_ADMIN, ROLE_SUBADMIN, SOURCE_ADMIN, or SOURCE_SUBADMIN authority is required to call this API.
		     * @summary Tag Multiple Objects
		     * @param {TaggedObjectsApiSetTagsToManyObjectsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof TaggedObjectsApi
		     */
		    TaggedObjectsApi.prototype.setTagsToManyObjects = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.TaggedObjectsApiFp)(this.configuration).setTagsToManyObjects(requestParameters.bulkTaggedObject, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return TaggedObjectsApi;
		}(base_1.BaseAPI));
		exports.TaggedObjectsApi = TaggedObjectsApi;
		/**
		 * TransformsApi - axios parameter creator
		 * @export
		 */
		var TransformsApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * Creates a new transform object immediately. By default, the internal flag is set to false to indicate that this is a custom transform. Only SailPoint employees have the ability to create a transform with internal set to true. Newly created Transforms can be used in the Identity Profile mappings within the UI. A token with transform write authority is required to call this API.
		         * @summary Create transform
		         * @param {Transform} transform The transform to be created.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createTransform: function (transform, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'transform' is not null or undefined
		                            (0, common_1.assertParamExists)('createTransform', 'transform', transform);
		                            localVarPath = "/transforms";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(transform, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Deletes the transform specified by the given ID. Attempting to delete a transform that is used in one or more Identity Profile mappings will result in an error. If this occurs, you must first remove the transform from all mappings before deleting the transform. A token with transform delete authority is required to call this API.
		         * @summary Delete a transform
		         * @param {string} id ID of the transform to delete
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteTransform: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('deleteTransform', 'id', id);
		                            localVarPath = "/transforms/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'DELETE' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns the transform specified by the given ID. A token with transform read authority is required to call this API.
		         * @summary Transform by ID
		         * @param {string} id ID of the transform to retrieve
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getTransform: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getTransform', 'id', id);
		                            localVarPath = "/transforms/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Gets a list of all saved transform objects. A token with transforms-list read authority is required to call this API.
		         * @summary List transforms
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [name] Name of the transform to retrieve from the list.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **internal**: *eq*  **name**: *eq, sw*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listTransforms: function (offset, limit, count, name, filters, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/transforms";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (name !== undefined) {
		                                localVarQueryParameter['name'] = name;
		                            }
		                            if (filters !== undefined) {
		                                localVarQueryParameter['filters'] = filters;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * Replaces the transform specified by the given ID with the transform provided in the request body. Only the \"attributes\" field is mutable. Attempting to change other properties (ex. \"name\" and \"type\") will result in an error. A token with transform write authority is required to call this API.
		         * @summary Update a transform
		         * @param {string} id ID of the transform to update
		         * @param {Transform} [transform] The updated transform object. Must include \&quot;name\&quot;, \&quot;type\&quot;, and \&quot;attributes\&quot; fields, but \&quot;name\&quot; and \&quot;type\&quot; must not be modified.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateTransform: function (id, transform, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('updateTransform', 'id', id);
		                            localVarPath = "/transforms/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'PUT' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(transform, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.TransformsApiAxiosParamCreator = TransformsApiAxiosParamCreator;
		/**
		 * TransformsApi - functional programming interface
		 * @export
		 */
		var TransformsApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.TransformsApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * Creates a new transform object immediately. By default, the internal flag is set to false to indicate that this is a custom transform. Only SailPoint employees have the ability to create a transform with internal set to true. Newly created Transforms can be used in the Identity Profile mappings within the UI. A token with transform write authority is required to call this API.
		         * @summary Create transform
		         * @param {Transform} transform The transform to be created.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createTransform: function (transform, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.createTransform(transform, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Deletes the transform specified by the given ID. Attempting to delete a transform that is used in one or more Identity Profile mappings will result in an error. If this occurs, you must first remove the transform from all mappings before deleting the transform. A token with transform delete authority is required to call this API.
		         * @summary Delete a transform
		         * @param {string} id ID of the transform to delete
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteTransform: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.deleteTransform(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API returns the transform specified by the given ID. A token with transform read authority is required to call this API.
		         * @summary Transform by ID
		         * @param {string} id ID of the transform to retrieve
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getTransform: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getTransform(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Gets a list of all saved transform objects. A token with transforms-list read authority is required to call this API.
		         * @summary List transforms
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [name] Name of the transform to retrieve from the list.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **internal**: *eq*  **name**: *eq, sw*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listTransforms: function (offset, limit, count, name, filters, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listTransforms(offset, limit, count, name, filters, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * Replaces the transform specified by the given ID with the transform provided in the request body. Only the \"attributes\" field is mutable. Attempting to change other properties (ex. \"name\" and \"type\") will result in an error. A token with transform write authority is required to call this API.
		         * @summary Update a transform
		         * @param {string} id ID of the transform to update
		         * @param {Transform} [transform] The updated transform object. Must include \&quot;name\&quot;, \&quot;type\&quot;, and \&quot;attributes\&quot; fields, but \&quot;name\&quot; and \&quot;type\&quot; must not be modified.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateTransform: function (id, transform, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.updateTransform(id, transform, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.TransformsApiFp = TransformsApiFp;
		/**
		 * TransformsApi - factory interface
		 * @export
		 */
		var TransformsApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.TransformsApiFp)(configuration);
		    return {
		        /**
		         * Creates a new transform object immediately. By default, the internal flag is set to false to indicate that this is a custom transform. Only SailPoint employees have the ability to create a transform with internal set to true. Newly created Transforms can be used in the Identity Profile mappings within the UI. A token with transform write authority is required to call this API.
		         * @summary Create transform
		         * @param {Transform} transform The transform to be created.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        createTransform: function (transform, axiosOptions) {
		            return localVarFp.createTransform(transform, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Deletes the transform specified by the given ID. Attempting to delete a transform that is used in one or more Identity Profile mappings will result in an error. If this occurs, you must first remove the transform from all mappings before deleting the transform. A token with transform delete authority is required to call this API.
		         * @summary Delete a transform
		         * @param {string} id ID of the transform to delete
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        deleteTransform: function (id, axiosOptions) {
		            return localVarFp.deleteTransform(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API returns the transform specified by the given ID. A token with transform read authority is required to call this API.
		         * @summary Transform by ID
		         * @param {string} id ID of the transform to retrieve
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getTransform: function (id, axiosOptions) {
		            return localVarFp.getTransform(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Gets a list of all saved transform objects. A token with transforms-list read authority is required to call this API.
		         * @summary List transforms
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [name] Name of the transform to retrieve from the list.
		         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **internal**: *eq*  **name**: *eq, sw*
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listTransforms: function (offset, limit, count, name, filters, axiosOptions) {
		            return localVarFp.listTransforms(offset, limit, count, name, filters, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * Replaces the transform specified by the given ID with the transform provided in the request body. Only the \"attributes\" field is mutable. Attempting to change other properties (ex. \"name\" and \"type\") will result in an error. A token with transform write authority is required to call this API.
		         * @summary Update a transform
		         * @param {string} id ID of the transform to update
		         * @param {Transform} [transform] The updated transform object. Must include \&quot;name\&quot;, \&quot;type\&quot;, and \&quot;attributes\&quot; fields, but \&quot;name\&quot; and \&quot;type\&quot; must not be modified.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        updateTransform: function (id, transform, axiosOptions) {
		            return localVarFp.updateTransform(id, transform, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.TransformsApiFactory = TransformsApiFactory;
		/**
		 * TransformsApi - object-oriented interface
		 * @export
		 * @class TransformsApi
		 * @extends {BaseAPI}
		 */
		var TransformsApi = /** @class */ (function (_super) {
		    __extends(TransformsApi, _super);
		    function TransformsApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * Creates a new transform object immediately. By default, the internal flag is set to false to indicate that this is a custom transform. Only SailPoint employees have the ability to create a transform with internal set to true. Newly created Transforms can be used in the Identity Profile mappings within the UI. A token with transform write authority is required to call this API.
		     * @summary Create transform
		     * @param {TransformsApiCreateTransformRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof TransformsApi
		     */
		    TransformsApi.prototype.createTransform = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.TransformsApiFp)(this.configuration).createTransform(requestParameters.transform, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Deletes the transform specified by the given ID. Attempting to delete a transform that is used in one or more Identity Profile mappings will result in an error. If this occurs, you must first remove the transform from all mappings before deleting the transform. A token with transform delete authority is required to call this API.
		     * @summary Delete a transform
		     * @param {TransformsApiDeleteTransformRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof TransformsApi
		     */
		    TransformsApi.prototype.deleteTransform = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.TransformsApiFp)(this.configuration).deleteTransform(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API returns the transform specified by the given ID. A token with transform read authority is required to call this API.
		     * @summary Transform by ID
		     * @param {TransformsApiGetTransformRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof TransformsApi
		     */
		    TransformsApi.prototype.getTransform = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.TransformsApiFp)(this.configuration).getTransform(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Gets a list of all saved transform objects. A token with transforms-list read authority is required to call this API.
		     * @summary List transforms
		     * @param {TransformsApiListTransformsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof TransformsApi
		     */
		    TransformsApi.prototype.listTransforms = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.TransformsApiFp)(this.configuration).listTransforms(requestParameters.offset, requestParameters.limit, requestParameters.count, requestParameters.name, requestParameters.filters, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * Replaces the transform specified by the given ID with the transform provided in the request body. Only the \"attributes\" field is mutable. Attempting to change other properties (ex. \"name\" and \"type\") will result in an error. A token with transform write authority is required to call this API.
		     * @summary Update a transform
		     * @param {TransformsApiUpdateTransformRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof TransformsApi
		     */
		    TransformsApi.prototype.updateTransform = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.TransformsApiFp)(this.configuration).updateTransform(requestParameters.id, requestParameters.transform, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return TransformsApi;
		}(base_1.BaseAPI));
		exports.TransformsApi = TransformsApi;
		/**
		 * WorkItemsApi - axios parameter creator
		 * @export
		 */
		var WorkItemsApiAxiosParamCreator = function (configuration) {
		    var _this = this;
		    return {
		        /**
		         * This API approves an Approval Item. Either an admin, or the owning/current user must make this request.
		         * @summary Approve an Approval Item
		         * @param {string} id The ID of the work item
		         * @param {string} approvalItemId The ID of the approval item.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        approveApprovalItem: function (id, approvalItemId, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('approveApprovalItem', 'id', id);
		                            // verify required parameter 'approvalItemId' is not null or undefined
		                            (0, common_1.assertParamExists)('approveApprovalItem', 'approvalItemId', approvalItemId);
		                            localVarPath = "/work-items/{id}/approve/{approvalItemId}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)))
		                                .replace("{".concat("approvalItemId", "}"), encodeURIComponent(String(approvalItemId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API bulk approves Approval Items. Either an admin, or the owning/current user must make this request.
		         * @summary Bulk approve Approval Items
		         * @param {string} id The ID of the work item
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        approveApprovalItemsInBulk: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('approveApprovalItemsInBulk', 'id', id);
		                            localVarPath = "/work-items/bulk-approve/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API completes a work item. Either an admin, or the owning/current user must make this request.
		         * @summary Complete a Work Item
		         * @param {string} id The ID of the work item
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        completeWorkItem: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('completeWorkItem', 'id', id);
		                            localVarPath = "/work-items/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets a collection of completed work items belonging to either the specified user(admin required), or the current user.
		         * @summary Completed Work Items
		         * @param {string} [ownerId] The id of the owner of the work item list being requested.  Either an admin, or the owning/current user must make this request.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getCompletedWorkItems: function (ownerId, limit, offset, count, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/work-items/completed";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (ownerId !== undefined) {
		                                localVarQueryParameter['ownerId'] = ownerId;
		                            }
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets a count of completed work items belonging to either the specified user(admin required), or the current user.
		         * @summary Count Completed Work Items
		         * @param {string} [ownerId] ID of the work item owner.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getCountCompletedWorkItems: function (ownerId, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/work-items/completed/count";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (ownerId !== undefined) {
		                                localVarQueryParameter['ownerId'] = ownerId;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets a count of work items belonging to either the specified user(admin required), or the current user.
		         * @summary Count Work Items
		         * @param {string} [ownerId] ID of the work item owner.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getCountWorkItems: function (ownerId, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/work-items/count";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (ownerId !== undefined) {
		                                localVarQueryParameter['ownerId'] = ownerId;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets the details of a Work Item belonging to either the specified user(admin required), or the current user.
		         * @summary Get a Work Item
		         * @param {string} id ID of the work item.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getWorkItem: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('getWorkItem', 'id', id);
		                            localVarPath = "/work-items/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets a summary of work items belonging to either the specified user(admin required), or the current user.
		         * @summary Work Items Summary
		         * @param {string} [ownerId] ID of the work item owner.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getWorkItemsSummary: function (ownerId, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/work-items/summary";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (ownerId !== undefined) {
		                                localVarQueryParameter['ownerId'] = ownerId;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets a collection of work items belonging to either the specified user(admin required), or the current user.
		         * @summary List Work Items
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [ownerId] ID of the work item owner.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listWorkItems: function (limit, offset, count, ownerId, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            localVarPath = "/work-items";
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'GET' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            if (limit !== undefined) {
		                                localVarQueryParameter['limit'] = limit;
		                            }
		                            if (offset !== undefined) {
		                                localVarQueryParameter['offset'] = offset;
		                            }
		                            if (count !== undefined) {
		                                localVarQueryParameter['count'] = count;
		                            }
		                            if (ownerId !== undefined) {
		                                localVarQueryParameter['ownerId'] = ownerId;
		                            }
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API rejects an Approval Item. Either an admin, or the owning/current user must make this request.
		         * @summary Reject an Approval Item
		         * @param {string} id The ID of the work item
		         * @param {string} approvalItemId The ID of the approval item.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        rejectApprovalItem: function (id, approvalItemId, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('rejectApprovalItem', 'id', id);
		                            // verify required parameter 'approvalItemId' is not null or undefined
		                            (0, common_1.assertParamExists)('rejectApprovalItem', 'approvalItemId', approvalItemId);
		                            localVarPath = "/work-items/{id}/reject/{approvalItemId}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)))
		                                .replace("{".concat("approvalItemId", "}"), encodeURIComponent(String(approvalItemId)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API bulk rejects Approval Items. Either an admin, or the owning/current user must make this request.
		         * @summary Bulk reject Approval Items
		         * @param {string} id The ID of the work item
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        rejectApprovalItemsInBulk: function (id, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('rejectApprovalItemsInBulk', 'id', id);
		                            localVarPath = "/work-items/bulk-reject/{id}"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		        /**
		         * This API submits account selections. Either an admin, or the owning/current user must make this request.
		         * @summary Submit Account Selections
		         * @param {string} id The ID of the work item
		         * @param {{ [key: string]: any; }} requestBody Account Selection Data map, keyed on fieldName
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        submitAccountSelection: function (id, requestBody, axiosOptions) {
		            if (axiosOptions === void 0) { axiosOptions = {}; }
		            return __awaiter(_this, void 0, void 0, function () {
		                var localVarPath, localVarUrlObj, baseOptions, localVarRequestOptions, localVarHeaderParameter, localVarQueryParameter, headersFromBaseOptions;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0:
		                            // verify required parameter 'id' is not null or undefined
		                            (0, common_1.assertParamExists)('submitAccountSelection', 'id', id);
		                            // verify required parameter 'requestBody' is not null or undefined
		                            (0, common_1.assertParamExists)('submitAccountSelection', 'requestBody', requestBody);
		                            localVarPath = "/work-items/{id}/submit-account-selection"
		                                .replace("{".concat("id", "}"), encodeURIComponent(String(id)));
		                            localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
		                            if (configuration) {
		                                baseOptions = configuration.baseOptions;
		                            }
		                            localVarRequestOptions = __assign(__assign({ method: 'POST' }, baseOptions), axiosOptions);
		                            localVarHeaderParameter = {};
		                            localVarQueryParameter = {};
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)
		                                // authentication UserContextAuth required
		                                // oauth required
		                            ];
		                        case 1:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            // authentication UserContextAuth required
		                            // oauth required
		                            return [4 /*yield*/, (0, common_1.setOAuthToObject)(localVarHeaderParameter, "UserContextAuth", [], configuration)];
		                        case 2:
		                            // authentication UserContextAuth required
		                            // oauth required
		                            _a.sent();
		                            localVarHeaderParameter['Content-Type'] = 'application/json';
		                            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
		                            headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
		                            localVarRequestOptions.headers = __assign(__assign(__assign({}, localVarHeaderParameter), headersFromBaseOptions), axiosOptions.headers);
		                            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(requestBody, localVarRequestOptions, configuration);
		                            return [2 /*return*/, {
		                                    url: (0, common_1.toPathString)(localVarUrlObj),
		                                    axiosOptions: localVarRequestOptions,
		                                }];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.WorkItemsApiAxiosParamCreator = WorkItemsApiAxiosParamCreator;
		/**
		 * WorkItemsApi - functional programming interface
		 * @export
		 */
		var WorkItemsApiFp = function (configuration) {
		    var localVarAxiosParamCreator = (0, exports.WorkItemsApiAxiosParamCreator)(configuration);
		    return {
		        /**
		         * This API approves an Approval Item. Either an admin, or the owning/current user must make this request.
		         * @summary Approve an Approval Item
		         * @param {string} id The ID of the work item
		         * @param {string} approvalItemId The ID of the approval item.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        approveApprovalItem: function (id, approvalItemId, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.approveApprovalItem(id, approvalItemId, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API bulk approves Approval Items. Either an admin, or the owning/current user must make this request.
		         * @summary Bulk approve Approval Items
		         * @param {string} id The ID of the work item
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        approveApprovalItemsInBulk: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.approveApprovalItemsInBulk(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API completes a work item. Either an admin, or the owning/current user must make this request.
		         * @summary Complete a Work Item
		         * @param {string} id The ID of the work item
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        completeWorkItem: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.completeWorkItem(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets a collection of completed work items belonging to either the specified user(admin required), or the current user.
		         * @summary Completed Work Items
		         * @param {string} [ownerId] The id of the owner of the work item list being requested.  Either an admin, or the owning/current user must make this request.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getCompletedWorkItems: function (ownerId, limit, offset, count, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getCompletedWorkItems(ownerId, limit, offset, count, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets a count of completed work items belonging to either the specified user(admin required), or the current user.
		         * @summary Count Completed Work Items
		         * @param {string} [ownerId] ID of the work item owner.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getCountCompletedWorkItems: function (ownerId, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getCountCompletedWorkItems(ownerId, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets a count of work items belonging to either the specified user(admin required), or the current user.
		         * @summary Count Work Items
		         * @param {string} [ownerId] ID of the work item owner.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getCountWorkItems: function (ownerId, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getCountWorkItems(ownerId, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets the details of a Work Item belonging to either the specified user(admin required), or the current user.
		         * @summary Get a Work Item
		         * @param {string} id ID of the work item.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getWorkItem: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getWorkItem(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets a summary of work items belonging to either the specified user(admin required), or the current user.
		         * @summary Work Items Summary
		         * @param {string} [ownerId] ID of the work item owner.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getWorkItemsSummary: function (ownerId, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.getWorkItemsSummary(ownerId, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This gets a collection of work items belonging to either the specified user(admin required), or the current user.
		         * @summary List Work Items
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [ownerId] ID of the work item owner.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listWorkItems: function (limit, offset, count, ownerId, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.listWorkItems(limit, offset, count, ownerId, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API rejects an Approval Item. Either an admin, or the owning/current user must make this request.
		         * @summary Reject an Approval Item
		         * @param {string} id The ID of the work item
		         * @param {string} approvalItemId The ID of the approval item.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        rejectApprovalItem: function (id, approvalItemId, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.rejectApprovalItem(id, approvalItemId, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API bulk rejects Approval Items. Either an admin, or the owning/current user must make this request.
		         * @summary Bulk reject Approval Items
		         * @param {string} id The ID of the work item
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        rejectApprovalItemsInBulk: function (id, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.rejectApprovalItemsInBulk(id, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		        /**
		         * This API submits account selections. Either an admin, or the owning/current user must make this request.
		         * @summary Submit Account Selections
		         * @param {string} id The ID of the work item
		         * @param {{ [key: string]: any; }} requestBody Account Selection Data map, keyed on fieldName
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        submitAccountSelection: function (id, requestBody, axiosOptions) {
		            return __awaiter(this, void 0, void 0, function () {
		                var localVarAxiosArgs;
		                return __generator(this, function (_a) {
		                    switch (_a.label) {
		                        case 0: return [4 /*yield*/, localVarAxiosParamCreator.submitAccountSelection(id, requestBody, axiosOptions)];
		                        case 1:
		                            localVarAxiosArgs = _a.sent();
		                            return [2 /*return*/, (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)];
		                    }
		                });
		            });
		        },
		    };
		};
		exports.WorkItemsApiFp = WorkItemsApiFp;
		/**
		 * WorkItemsApi - factory interface
		 * @export
		 */
		var WorkItemsApiFactory = function (configuration, basePath, axios) {
		    var localVarFp = (0, exports.WorkItemsApiFp)(configuration);
		    return {
		        /**
		         * This API approves an Approval Item. Either an admin, or the owning/current user must make this request.
		         * @summary Approve an Approval Item
		         * @param {string} id The ID of the work item
		         * @param {string} approvalItemId The ID of the approval item.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        approveApprovalItem: function (id, approvalItemId, axiosOptions) {
		            return localVarFp.approveApprovalItem(id, approvalItemId, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API bulk approves Approval Items. Either an admin, or the owning/current user must make this request.
		         * @summary Bulk approve Approval Items
		         * @param {string} id The ID of the work item
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        approveApprovalItemsInBulk: function (id, axiosOptions) {
		            return localVarFp.approveApprovalItemsInBulk(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API completes a work item. Either an admin, or the owning/current user must make this request.
		         * @summary Complete a Work Item
		         * @param {string} id The ID of the work item
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        completeWorkItem: function (id, axiosOptions) {
		            return localVarFp.completeWorkItem(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This gets a collection of completed work items belonging to either the specified user(admin required), or the current user.
		         * @summary Completed Work Items
		         * @param {string} [ownerId] The id of the owner of the work item list being requested.  Either an admin, or the owning/current user must make this request.
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getCompletedWorkItems: function (ownerId, limit, offset, count, axiosOptions) {
		            return localVarFp.getCompletedWorkItems(ownerId, limit, offset, count, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This gets a count of completed work items belonging to either the specified user(admin required), or the current user.
		         * @summary Count Completed Work Items
		         * @param {string} [ownerId] ID of the work item owner.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getCountCompletedWorkItems: function (ownerId, axiosOptions) {
		            return localVarFp.getCountCompletedWorkItems(ownerId, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This gets a count of work items belonging to either the specified user(admin required), or the current user.
		         * @summary Count Work Items
		         * @param {string} [ownerId] ID of the work item owner.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getCountWorkItems: function (ownerId, axiosOptions) {
		            return localVarFp.getCountWorkItems(ownerId, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This gets the details of a Work Item belonging to either the specified user(admin required), or the current user.
		         * @summary Get a Work Item
		         * @param {string} id ID of the work item.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getWorkItem: function (id, axiosOptions) {
		            return localVarFp.getWorkItem(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This gets a summary of work items belonging to either the specified user(admin required), or the current user.
		         * @summary Work Items Summary
		         * @param {string} [ownerId] ID of the work item owner.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        getWorkItemsSummary: function (ownerId, axiosOptions) {
		            return localVarFp.getWorkItemsSummary(ownerId, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This gets a collection of work items belonging to either the specified user(admin required), or the current user.
		         * @summary List Work Items
		         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
		         * @param {string} [ownerId] ID of the work item owner.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        listWorkItems: function (limit, offset, count, ownerId, axiosOptions) {
		            return localVarFp.listWorkItems(limit, offset, count, ownerId, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API rejects an Approval Item. Either an admin, or the owning/current user must make this request.
		         * @summary Reject an Approval Item
		         * @param {string} id The ID of the work item
		         * @param {string} approvalItemId The ID of the approval item.
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        rejectApprovalItem: function (id, approvalItemId, axiosOptions) {
		            return localVarFp.rejectApprovalItem(id, approvalItemId, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API bulk rejects Approval Items. Either an admin, or the owning/current user must make this request.
		         * @summary Bulk reject Approval Items
		         * @param {string} id The ID of the work item
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        rejectApprovalItemsInBulk: function (id, axiosOptions) {
		            return localVarFp.rejectApprovalItemsInBulk(id, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		        /**
		         * This API submits account selections. Either an admin, or the owning/current user must make this request.
		         * @summary Submit Account Selections
		         * @param {string} id The ID of the work item
		         * @param {{ [key: string]: any; }} requestBody Account Selection Data map, keyed on fieldName
		         * @param {*} [axiosOptions] Override http request option.
		         * @throws {RequiredError}
		         */
		        submitAccountSelection: function (id, requestBody, axiosOptions) {
		            return localVarFp.submitAccountSelection(id, requestBody, axiosOptions).then(function (request) { return request(axios, basePath); });
		        },
		    };
		};
		exports.WorkItemsApiFactory = WorkItemsApiFactory;
		/**
		 * WorkItemsApi - object-oriented interface
		 * @export
		 * @class WorkItemsApi
		 * @extends {BaseAPI}
		 */
		var WorkItemsApi = /** @class */ (function (_super) {
		    __extends(WorkItemsApi, _super);
		    function WorkItemsApi() {
		        return _super !== null && _super.apply(this, arguments) || this;
		    }
		    /**
		     * This API approves an Approval Item. Either an admin, or the owning/current user must make this request.
		     * @summary Approve an Approval Item
		     * @param {WorkItemsApiApproveApprovalItemRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof WorkItemsApi
		     */
		    WorkItemsApi.prototype.approveApprovalItem = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.WorkItemsApiFp)(this.configuration).approveApprovalItem(requestParameters.id, requestParameters.approvalItemId, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API bulk approves Approval Items. Either an admin, or the owning/current user must make this request.
		     * @summary Bulk approve Approval Items
		     * @param {WorkItemsApiApproveApprovalItemsInBulkRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof WorkItemsApi
		     */
		    WorkItemsApi.prototype.approveApprovalItemsInBulk = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.WorkItemsApiFp)(this.configuration).approveApprovalItemsInBulk(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API completes a work item. Either an admin, or the owning/current user must make this request.
		     * @summary Complete a Work Item
		     * @param {WorkItemsApiCompleteWorkItemRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof WorkItemsApi
		     */
		    WorkItemsApi.prototype.completeWorkItem = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.WorkItemsApiFp)(this.configuration).completeWorkItem(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This gets a collection of completed work items belonging to either the specified user(admin required), or the current user.
		     * @summary Completed Work Items
		     * @param {WorkItemsApiGetCompletedWorkItemsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof WorkItemsApi
		     */
		    WorkItemsApi.prototype.getCompletedWorkItems = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.WorkItemsApiFp)(this.configuration).getCompletedWorkItems(requestParameters.ownerId, requestParameters.limit, requestParameters.offset, requestParameters.count, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This gets a count of completed work items belonging to either the specified user(admin required), or the current user.
		     * @summary Count Completed Work Items
		     * @param {WorkItemsApiGetCountCompletedWorkItemsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof WorkItemsApi
		     */
		    WorkItemsApi.prototype.getCountCompletedWorkItems = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.WorkItemsApiFp)(this.configuration).getCountCompletedWorkItems(requestParameters.ownerId, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This gets a count of work items belonging to either the specified user(admin required), or the current user.
		     * @summary Count Work Items
		     * @param {WorkItemsApiGetCountWorkItemsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof WorkItemsApi
		     */
		    WorkItemsApi.prototype.getCountWorkItems = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.WorkItemsApiFp)(this.configuration).getCountWorkItems(requestParameters.ownerId, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This gets the details of a Work Item belonging to either the specified user(admin required), or the current user.
		     * @summary Get a Work Item
		     * @param {WorkItemsApiGetWorkItemRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof WorkItemsApi
		     */
		    WorkItemsApi.prototype.getWorkItem = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.WorkItemsApiFp)(this.configuration).getWorkItem(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This gets a summary of work items belonging to either the specified user(admin required), or the current user.
		     * @summary Work Items Summary
		     * @param {WorkItemsApiGetWorkItemsSummaryRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof WorkItemsApi
		     */
		    WorkItemsApi.prototype.getWorkItemsSummary = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.WorkItemsApiFp)(this.configuration).getWorkItemsSummary(requestParameters.ownerId, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This gets a collection of work items belonging to either the specified user(admin required), or the current user.
		     * @summary List Work Items
		     * @param {WorkItemsApiListWorkItemsRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof WorkItemsApi
		     */
		    WorkItemsApi.prototype.listWorkItems = function (requestParameters, axiosOptions) {
		        var _this = this;
		        if (requestParameters === void 0) { requestParameters = {}; }
		        return (0, exports.WorkItemsApiFp)(this.configuration).listWorkItems(requestParameters.limit, requestParameters.offset, requestParameters.count, requestParameters.ownerId, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API rejects an Approval Item. Either an admin, or the owning/current user must make this request.
		     * @summary Reject an Approval Item
		     * @param {WorkItemsApiRejectApprovalItemRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof WorkItemsApi
		     */
		    WorkItemsApi.prototype.rejectApprovalItem = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.WorkItemsApiFp)(this.configuration).rejectApprovalItem(requestParameters.id, requestParameters.approvalItemId, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API bulk rejects Approval Items. Either an admin, or the owning/current user must make this request.
		     * @summary Bulk reject Approval Items
		     * @param {WorkItemsApiRejectApprovalItemsInBulkRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof WorkItemsApi
		     */
		    WorkItemsApi.prototype.rejectApprovalItemsInBulk = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.WorkItemsApiFp)(this.configuration).rejectApprovalItemsInBulk(requestParameters.id, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    /**
		     * This API submits account selections. Either an admin, or the owning/current user must make this request.
		     * @summary Submit Account Selections
		     * @param {WorkItemsApiSubmitAccountSelectionRequest} requestParameters Request parameters.
		     * @param {*} [axiosOptions] Override http request option.
		     * @throws {RequiredError}
		     * @memberof WorkItemsApi
		     */
		    WorkItemsApi.prototype.submitAccountSelection = function (requestParameters, axiosOptions) {
		        var _this = this;
		        return (0, exports.WorkItemsApiFp)(this.configuration).submitAccountSelection(requestParameters.id, requestParameters.requestBody, axiosOptions).then(function (request) { return request(_this.axios, _this.basePath); });
		    };
		    return WorkItemsApi;
		}(base_1.BaseAPI));
		exports.WorkItemsApi = WorkItemsApi;
		
	} (api));
	return api;
}

var configuration$1 = {};

var hasRequiredConfiguration$1;

function requireConfiguration$1 () {
	if (hasRequiredConfiguration$1) return configuration$1;
	hasRequiredConfiguration$1 = 1;
	/* tslint:disable */
	/* eslint-disable */
	/**
	 * IdentityNow V3 API
	 * Use these APIs to interact with the IdentityNow platform to achieve repeatable, automated processes with greater scalability. We encourage you to join the SailPoint Developer Community forum at https://developer.sailpoint.com/discuss to connect with other developers using our APIs.
	 *
	 * The version of the OpenAPI document: 3.0.0
	 *
	 *
	 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
	 * https://openapi-generator.tech
	 * Do not edit the class manually.
	 */
	Object.defineProperty(configuration$1, "__esModule", { value: true });
	configuration$1.Configuration = void 0;
	var Configuration = /** @class */ (function () {
	    function Configuration(param) {
	        if (param === void 0) { param = {}; }
	        this.apiKey = param.apiKey;
	        this.username = param.username;
	        this.password = param.password;
	        this.accessToken = param.accessToken;
	        this.basePath = param.basePath;
	        this.baseOptions = param.baseOptions;
	        this.formDataCtor = param.formDataCtor;
	    }
	    /**
	     * Check if the given MIME is a JSON MIME.
	     * JSON MIME examples:
	     *   application/json
	     *   application/json; charset=UTF8
	     *   APPLICATION/JSON
	     *   application/vnd.company+json
	     * @param mime - MIME (Multipurpose Internet Mail Extensions)
	     * @return True if the given MIME is JSON, false otherwise.
	     */
	    Configuration.prototype.isJsonMime = function (mime) {
	        var jsonMime = new RegExp('^(application\/json|[^;/ \t]+\/[^;/ \t]+[+]json)[ \t]*(;.*)?$', 'i');
	        return mime !== null && (jsonMime.test(mime) || mime.toLowerCase() === 'application/json-patch+json');
	    };
	    return Configuration;
	}());
	configuration$1.Configuration = Configuration;
	
	return configuration$1;
}

var configuration = {};

var jsYaml = {};

var loader = {};

var common = {};

var hasRequiredCommon;

function requireCommon () {
	if (hasRequiredCommon) return common;
	hasRequiredCommon = 1;


	function isNothing(subject) {
	  return (typeof subject === 'undefined') || (subject === null);
	}


	function isObject(subject) {
	  return (typeof subject === 'object') && (subject !== null);
	}


	function toArray(sequence) {
	  if (Array.isArray(sequence)) return sequence;
	  else if (isNothing(sequence)) return [];

	  return [ sequence ];
	}


	function extend(target, source) {
	  var index, length, key, sourceKeys;

	  if (source) {
	    sourceKeys = Object.keys(source);

	    for (index = 0, length = sourceKeys.length; index < length; index += 1) {
	      key = sourceKeys[index];
	      target[key] = source[key];
	    }
	  }

	  return target;
	}


	function repeat(string, count) {
	  var result = '', cycle;

	  for (cycle = 0; cycle < count; cycle += 1) {
	    result += string;
	  }

	  return result;
	}


	function isNegativeZero(number) {
	  return (number === 0) && (Number.NEGATIVE_INFINITY === 1 / number);
	}


	common.isNothing      = isNothing;
	common.isObject       = isObject;
	common.toArray        = toArray;
	common.repeat         = repeat;
	common.isNegativeZero = isNegativeZero;
	common.extend         = extend;
	return common;
}

var exception;
var hasRequiredException;

function requireException () {
	if (hasRequiredException) return exception;
	hasRequiredException = 1;


	function formatError(exception, compact) {
	  var where = '', message = exception.reason || '(unknown reason)';

	  if (!exception.mark) return message;

	  if (exception.mark.name) {
	    where += 'in "' + exception.mark.name + '" ';
	  }

	  where += '(' + (exception.mark.line + 1) + ':' + (exception.mark.column + 1) + ')';

	  if (!compact && exception.mark.snippet) {
	    where += '\n\n' + exception.mark.snippet;
	  }

	  return message + ' ' + where;
	}


	function YAMLException(reason, mark) {
	  // Super constructor
	  Error.call(this);

	  this.name = 'YAMLException';
	  this.reason = reason;
	  this.mark = mark;
	  this.message = formatError(this, false);

	  // Include stack trace in error object
	  if (Error.captureStackTrace) {
	    // Chrome and NodeJS
	    Error.captureStackTrace(this, this.constructor);
	  } else {
	    // FF, IE 10+ and Safari 6+. Fallback for others
	    this.stack = (new Error()).stack || '';
	  }
	}


	// Inherit from Error
	YAMLException.prototype = Object.create(Error.prototype);
	YAMLException.prototype.constructor = YAMLException;


	YAMLException.prototype.toString = function toString(compact) {
	  return this.name + ': ' + formatError(this, compact);
	};


	exception = YAMLException;
	return exception;
}

var snippet;
var hasRequiredSnippet;

function requireSnippet () {
	if (hasRequiredSnippet) return snippet;
	hasRequiredSnippet = 1;


	var common = requireCommon();


	// get snippet for a single line, respecting maxLength
	function getLine(buffer, lineStart, lineEnd, position, maxLineLength) {
	  var head = '';
	  var tail = '';
	  var maxHalfLength = Math.floor(maxLineLength / 2) - 1;

	  if (position - lineStart > maxHalfLength) {
	    head = ' ... ';
	    lineStart = position - maxHalfLength + head.length;
	  }

	  if (lineEnd - position > maxHalfLength) {
	    tail = ' ...';
	    lineEnd = position + maxHalfLength - tail.length;
	  }

	  return {
	    str: head + buffer.slice(lineStart, lineEnd).replace(/\t/g, '→') + tail,
	    pos: position - lineStart + head.length // relative position
	  };
	}


	function padStart(string, max) {
	  return common.repeat(' ', max - string.length) + string;
	}


	function makeSnippet(mark, options) {
	  options = Object.create(options || null);

	  if (!mark.buffer) return null;

	  if (!options.maxLength) options.maxLength = 79;
	  if (typeof options.indent      !== 'number') options.indent      = 1;
	  if (typeof options.linesBefore !== 'number') options.linesBefore = 3;
	  if (typeof options.linesAfter  !== 'number') options.linesAfter  = 2;

	  var re = /\r?\n|\r|\0/g;
	  var lineStarts = [ 0 ];
	  var lineEnds = [];
	  var match;
	  var foundLineNo = -1;

	  while ((match = re.exec(mark.buffer))) {
	    lineEnds.push(match.index);
	    lineStarts.push(match.index + match[0].length);

	    if (mark.position <= match.index && foundLineNo < 0) {
	      foundLineNo = lineStarts.length - 2;
	    }
	  }

	  if (foundLineNo < 0) foundLineNo = lineStarts.length - 1;

	  var result = '', i, line;
	  var lineNoLength = Math.min(mark.line + options.linesAfter, lineEnds.length).toString().length;
	  var maxLineLength = options.maxLength - (options.indent + lineNoLength + 3);

	  for (i = 1; i <= options.linesBefore; i++) {
	    if (foundLineNo - i < 0) break;
	    line = getLine(
	      mark.buffer,
	      lineStarts[foundLineNo - i],
	      lineEnds[foundLineNo - i],
	      mark.position - (lineStarts[foundLineNo] - lineStarts[foundLineNo - i]),
	      maxLineLength
	    );
	    result = common.repeat(' ', options.indent) + padStart((mark.line - i + 1).toString(), lineNoLength) +
	      ' | ' + line.str + '\n' + result;
	  }

	  line = getLine(mark.buffer, lineStarts[foundLineNo], lineEnds[foundLineNo], mark.position, maxLineLength);
	  result += common.repeat(' ', options.indent) + padStart((mark.line + 1).toString(), lineNoLength) +
	    ' | ' + line.str + '\n';
	  result += common.repeat('-', options.indent + lineNoLength + 3 + line.pos) + '^' + '\n';

	  for (i = 1; i <= options.linesAfter; i++) {
	    if (foundLineNo + i >= lineEnds.length) break;
	    line = getLine(
	      mark.buffer,
	      lineStarts[foundLineNo + i],
	      lineEnds[foundLineNo + i],
	      mark.position - (lineStarts[foundLineNo] - lineStarts[foundLineNo + i]),
	      maxLineLength
	    );
	    result += common.repeat(' ', options.indent) + padStart((mark.line + i + 1).toString(), lineNoLength) +
	      ' | ' + line.str + '\n';
	  }

	  return result.replace(/\n$/, '');
	}


	snippet = makeSnippet;
	return snippet;
}

var type;
var hasRequiredType;

function requireType () {
	if (hasRequiredType) return type;
	hasRequiredType = 1;

	var YAMLException = requireException();

	var TYPE_CONSTRUCTOR_OPTIONS = [
	  'kind',
	  'multi',
	  'resolve',
	  'construct',
	  'instanceOf',
	  'predicate',
	  'represent',
	  'representName',
	  'defaultStyle',
	  'styleAliases'
	];

	var YAML_NODE_KINDS = [
	  'scalar',
	  'sequence',
	  'mapping'
	];

	function compileStyleAliases(map) {
	  var result = {};

	  if (map !== null) {
	    Object.keys(map).forEach(function (style) {
	      map[style].forEach(function (alias) {
	        result[String(alias)] = style;
	      });
	    });
	  }

	  return result;
	}

	function Type(tag, options) {
	  options = options || {};

	  Object.keys(options).forEach(function (name) {
	    if (TYPE_CONSTRUCTOR_OPTIONS.indexOf(name) === -1) {
	      throw new YAMLException('Unknown option "' + name + '" is met in definition of "' + tag + '" YAML type.');
	    }
	  });

	  // TODO: Add tag format check.
	  this.options       = options; // keep original options in case user wants to extend this type later
	  this.tag           = tag;
	  this.kind          = options['kind']          || null;
	  this.resolve       = options['resolve']       || function () { return true; };
	  this.construct     = options['construct']     || function (data) { return data; };
	  this.instanceOf    = options['instanceOf']    || null;
	  this.predicate     = options['predicate']     || null;
	  this.represent     = options['represent']     || null;
	  this.representName = options['representName'] || null;
	  this.defaultStyle  = options['defaultStyle']  || null;
	  this.multi         = options['multi']         || false;
	  this.styleAliases  = compileStyleAliases(options['styleAliases'] || null);

	  if (YAML_NODE_KINDS.indexOf(this.kind) === -1) {
	    throw new YAMLException('Unknown kind "' + this.kind + '" is specified for "' + tag + '" YAML type.');
	  }
	}

	type = Type;
	return type;
}

var schema;
var hasRequiredSchema;

function requireSchema () {
	if (hasRequiredSchema) return schema;
	hasRequiredSchema = 1;

	/*eslint-disable max-len*/

	var YAMLException = requireException();
	var Type          = requireType();


	function compileList(schema, name) {
	  var result = [];

	  schema[name].forEach(function (currentType) {
	    var newIndex = result.length;

	    result.forEach(function (previousType, previousIndex) {
	      if (previousType.tag === currentType.tag &&
	          previousType.kind === currentType.kind &&
	          previousType.multi === currentType.multi) {

	        newIndex = previousIndex;
	      }
	    });

	    result[newIndex] = currentType;
	  });

	  return result;
	}


	function compileMap(/* lists... */) {
	  var result = {
	        scalar: {},
	        sequence: {},
	        mapping: {},
	        fallback: {},
	        multi: {
	          scalar: [],
	          sequence: [],
	          mapping: [],
	          fallback: []
	        }
	      }, index, length;

	  function collectType(type) {
	    if (type.multi) {
	      result.multi[type.kind].push(type);
	      result.multi['fallback'].push(type);
	    } else {
	      result[type.kind][type.tag] = result['fallback'][type.tag] = type;
	    }
	  }

	  for (index = 0, length = arguments.length; index < length; index += 1) {
	    arguments[index].forEach(collectType);
	  }
	  return result;
	}


	function Schema(definition) {
	  return this.extend(definition);
	}


	Schema.prototype.extend = function extend(definition) {
	  var implicit = [];
	  var explicit = [];

	  if (definition instanceof Type) {
	    // Schema.extend(type)
	    explicit.push(definition);

	  } else if (Array.isArray(definition)) {
	    // Schema.extend([ type1, type2, ... ])
	    explicit = explicit.concat(definition);

	  } else if (definition && (Array.isArray(definition.implicit) || Array.isArray(definition.explicit))) {
	    // Schema.extend({ explicit: [ type1, type2, ... ], implicit: [ type1, type2, ... ] })
	    if (definition.implicit) implicit = implicit.concat(definition.implicit);
	    if (definition.explicit) explicit = explicit.concat(definition.explicit);

	  } else {
	    throw new YAMLException('Schema.extend argument should be a Type, [ Type ], ' +
	      'or a schema definition ({ implicit: [...], explicit: [...] })');
	  }

	  implicit.forEach(function (type) {
	    if (!(type instanceof Type)) {
	      throw new YAMLException('Specified list of YAML types (or a single Type object) contains a non-Type object.');
	    }

	    if (type.loadKind && type.loadKind !== 'scalar') {
	      throw new YAMLException('There is a non-scalar type in the implicit list of a schema. Implicit resolving of such types is not supported.');
	    }

	    if (type.multi) {
	      throw new YAMLException('There is a multi type in the implicit list of a schema. Multi tags can only be listed as explicit.');
	    }
	  });

	  explicit.forEach(function (type) {
	    if (!(type instanceof Type)) {
	      throw new YAMLException('Specified list of YAML types (or a single Type object) contains a non-Type object.');
	    }
	  });

	  var result = Object.create(Schema.prototype);

	  result.implicit = (this.implicit || []).concat(implicit);
	  result.explicit = (this.explicit || []).concat(explicit);

	  result.compiledImplicit = compileList(result, 'implicit');
	  result.compiledExplicit = compileList(result, 'explicit');
	  result.compiledTypeMap  = compileMap(result.compiledImplicit, result.compiledExplicit);

	  return result;
	};


	schema = Schema;
	return schema;
}

var str;
var hasRequiredStr;

function requireStr () {
	if (hasRequiredStr) return str;
	hasRequiredStr = 1;

	var Type = requireType();

	str = new Type('tag:yaml.org,2002:str', {
	  kind: 'scalar',
	  construct: function (data) { return data !== null ? data : ''; }
	});
	return str;
}

var seq;
var hasRequiredSeq;

function requireSeq () {
	if (hasRequiredSeq) return seq;
	hasRequiredSeq = 1;

	var Type = requireType();

	seq = new Type('tag:yaml.org,2002:seq', {
	  kind: 'sequence',
	  construct: function (data) { return data !== null ? data : []; }
	});
	return seq;
}

var map;
var hasRequiredMap;

function requireMap () {
	if (hasRequiredMap) return map;
	hasRequiredMap = 1;

	var Type = requireType();

	map = new Type('tag:yaml.org,2002:map', {
	  kind: 'mapping',
	  construct: function (data) { return data !== null ? data : {}; }
	});
	return map;
}

var failsafe;
var hasRequiredFailsafe;

function requireFailsafe () {
	if (hasRequiredFailsafe) return failsafe;
	hasRequiredFailsafe = 1;


	var Schema = requireSchema();


	failsafe = new Schema({
	  explicit: [
	    requireStr(),
	    requireSeq(),
	    requireMap()
	  ]
	});
	return failsafe;
}

var _null;
var hasRequired_null;

function require_null () {
	if (hasRequired_null) return _null;
	hasRequired_null = 1;

	var Type = requireType();

	function resolveYamlNull(data) {
	  if (data === null) return true;

	  var max = data.length;

	  return (max === 1 && data === '~') ||
	         (max === 4 && (data === 'null' || data === 'Null' || data === 'NULL'));
	}

	function constructYamlNull() {
	  return null;
	}

	function isNull(object) {
	  return object === null;
	}

	_null = new Type('tag:yaml.org,2002:null', {
	  kind: 'scalar',
	  resolve: resolveYamlNull,
	  construct: constructYamlNull,
	  predicate: isNull,
	  represent: {
	    canonical: function () { return '~';    },
	    lowercase: function () { return 'null'; },
	    uppercase: function () { return 'NULL'; },
	    camelcase: function () { return 'Null'; },
	    empty:     function () { return '';     }
	  },
	  defaultStyle: 'lowercase'
	});
	return _null;
}

var bool;
var hasRequiredBool;

function requireBool () {
	if (hasRequiredBool) return bool;
	hasRequiredBool = 1;

	var Type = requireType();

	function resolveYamlBoolean(data) {
	  if (data === null) return false;

	  var max = data.length;

	  return (max === 4 && (data === 'true' || data === 'True' || data === 'TRUE')) ||
	         (max === 5 && (data === 'false' || data === 'False' || data === 'FALSE'));
	}

	function constructYamlBoolean(data) {
	  return data === 'true' ||
	         data === 'True' ||
	         data === 'TRUE';
	}

	function isBoolean(object) {
	  return Object.prototype.toString.call(object) === '[object Boolean]';
	}

	bool = new Type('tag:yaml.org,2002:bool', {
	  kind: 'scalar',
	  resolve: resolveYamlBoolean,
	  construct: constructYamlBoolean,
	  predicate: isBoolean,
	  represent: {
	    lowercase: function (object) { return object ? 'true' : 'false'; },
	    uppercase: function (object) { return object ? 'TRUE' : 'FALSE'; },
	    camelcase: function (object) { return object ? 'True' : 'False'; }
	  },
	  defaultStyle: 'lowercase'
	});
	return bool;
}

var int;
var hasRequiredInt;

function requireInt () {
	if (hasRequiredInt) return int;
	hasRequiredInt = 1;

	var common = requireCommon();
	var Type   = requireType();

	function isHexCode(c) {
	  return ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */)) ||
	         ((0x41/* A */ <= c) && (c <= 0x46/* F */)) ||
	         ((0x61/* a */ <= c) && (c <= 0x66/* f */));
	}

	function isOctCode(c) {
	  return ((0x30/* 0 */ <= c) && (c <= 0x37/* 7 */));
	}

	function isDecCode(c) {
	  return ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */));
	}

	function resolveYamlInteger(data) {
	  if (data === null) return false;

	  var max = data.length,
	      index = 0,
	      hasDigits = false,
	      ch;

	  if (!max) return false;

	  ch = data[index];

	  // sign
	  if (ch === '-' || ch === '+') {
	    ch = data[++index];
	  }

	  if (ch === '0') {
	    // 0
	    if (index + 1 === max) return true;
	    ch = data[++index];

	    // base 2, base 8, base 16

	    if (ch === 'b') {
	      // base 2
	      index++;

	      for (; index < max; index++) {
	        ch = data[index];
	        if (ch === '_') continue;
	        if (ch !== '0' && ch !== '1') return false;
	        hasDigits = true;
	      }
	      return hasDigits && ch !== '_';
	    }


	    if (ch === 'x') {
	      // base 16
	      index++;

	      for (; index < max; index++) {
	        ch = data[index];
	        if (ch === '_') continue;
	        if (!isHexCode(data.charCodeAt(index))) return false;
	        hasDigits = true;
	      }
	      return hasDigits && ch !== '_';
	    }


	    if (ch === 'o') {
	      // base 8
	      index++;

	      for (; index < max; index++) {
	        ch = data[index];
	        if (ch === '_') continue;
	        if (!isOctCode(data.charCodeAt(index))) return false;
	        hasDigits = true;
	      }
	      return hasDigits && ch !== '_';
	    }
	  }

	  // base 10 (except 0)

	  // value should not start with `_`;
	  if (ch === '_') return false;

	  for (; index < max; index++) {
	    ch = data[index];
	    if (ch === '_') continue;
	    if (!isDecCode(data.charCodeAt(index))) {
	      return false;
	    }
	    hasDigits = true;
	  }

	  // Should have digits and should not end with `_`
	  if (!hasDigits || ch === '_') return false;

	  return true;
	}

	function constructYamlInteger(data) {
	  var value = data, sign = 1, ch;

	  if (value.indexOf('_') !== -1) {
	    value = value.replace(/_/g, '');
	  }

	  ch = value[0];

	  if (ch === '-' || ch === '+') {
	    if (ch === '-') sign = -1;
	    value = value.slice(1);
	    ch = value[0];
	  }

	  if (value === '0') return 0;

	  if (ch === '0') {
	    if (value[1] === 'b') return sign * parseInt(value.slice(2), 2);
	    if (value[1] === 'x') return sign * parseInt(value.slice(2), 16);
	    if (value[1] === 'o') return sign * parseInt(value.slice(2), 8);
	  }

	  return sign * parseInt(value, 10);
	}

	function isInteger(object) {
	  return (Object.prototype.toString.call(object)) === '[object Number]' &&
	         (object % 1 === 0 && !common.isNegativeZero(object));
	}

	int = new Type('tag:yaml.org,2002:int', {
	  kind: 'scalar',
	  resolve: resolveYamlInteger,
	  construct: constructYamlInteger,
	  predicate: isInteger,
	  represent: {
	    binary:      function (obj) { return obj >= 0 ? '0b' + obj.toString(2) : '-0b' + obj.toString(2).slice(1); },
	    octal:       function (obj) { return obj >= 0 ? '0o'  + obj.toString(8) : '-0o'  + obj.toString(8).slice(1); },
	    decimal:     function (obj) { return obj.toString(10); },
	    /* eslint-disable max-len */
	    hexadecimal: function (obj) { return obj >= 0 ? '0x' + obj.toString(16).toUpperCase() :  '-0x' + obj.toString(16).toUpperCase().slice(1); }
	  },
	  defaultStyle: 'decimal',
	  styleAliases: {
	    binary:      [ 2,  'bin' ],
	    octal:       [ 8,  'oct' ],
	    decimal:     [ 10, 'dec' ],
	    hexadecimal: [ 16, 'hex' ]
	  }
	});
	return int;
}

var float;
var hasRequiredFloat;

function requireFloat () {
	if (hasRequiredFloat) return float;
	hasRequiredFloat = 1;

	var common = requireCommon();
	var Type   = requireType();

	var YAML_FLOAT_PATTERN = new RegExp(
	  // 2.5e4, 2.5 and integers
	  '^(?:[-+]?(?:[0-9][0-9_]*)(?:\\.[0-9_]*)?(?:[eE][-+]?[0-9]+)?' +
	  // .2e4, .2
	  // special case, seems not from spec
	  '|\\.[0-9_]+(?:[eE][-+]?[0-9]+)?' +
	  // .inf
	  '|[-+]?\\.(?:inf|Inf|INF)' +
	  // .nan
	  '|\\.(?:nan|NaN|NAN))$');

	function resolveYamlFloat(data) {
	  if (data === null) return false;

	  if (!YAML_FLOAT_PATTERN.test(data) ||
	      // Quick hack to not allow integers end with `_`
	      // Probably should update regexp & check speed
	      data[data.length - 1] === '_') {
	    return false;
	  }

	  return true;
	}

	function constructYamlFloat(data) {
	  var value, sign;

	  value  = data.replace(/_/g, '').toLowerCase();
	  sign   = value[0] === '-' ? -1 : 1;

	  if ('+-'.indexOf(value[0]) >= 0) {
	    value = value.slice(1);
	  }

	  if (value === '.inf') {
	    return (sign === 1) ? Number.POSITIVE_INFINITY : Number.NEGATIVE_INFINITY;

	  } else if (value === '.nan') {
	    return NaN;
	  }
	  return sign * parseFloat(value, 10);
	}


	var SCIENTIFIC_WITHOUT_DOT = /^[-+]?[0-9]+e/;

	function representYamlFloat(object, style) {
	  var res;

	  if (isNaN(object)) {
	    switch (style) {
	      case 'lowercase': return '.nan';
	      case 'uppercase': return '.NAN';
	      case 'camelcase': return '.NaN';
	    }
	  } else if (Number.POSITIVE_INFINITY === object) {
	    switch (style) {
	      case 'lowercase': return '.inf';
	      case 'uppercase': return '.INF';
	      case 'camelcase': return '.Inf';
	    }
	  } else if (Number.NEGATIVE_INFINITY === object) {
	    switch (style) {
	      case 'lowercase': return '-.inf';
	      case 'uppercase': return '-.INF';
	      case 'camelcase': return '-.Inf';
	    }
	  } else if (common.isNegativeZero(object)) {
	    return '-0.0';
	  }

	  res = object.toString(10);

	  // JS stringifier can build scientific format without dots: 5e-100,
	  // while YAML requres dot: 5.e-100. Fix it with simple hack

	  return SCIENTIFIC_WITHOUT_DOT.test(res) ? res.replace('e', '.e') : res;
	}

	function isFloat(object) {
	  return (Object.prototype.toString.call(object) === '[object Number]') &&
	         (object % 1 !== 0 || common.isNegativeZero(object));
	}

	float = new Type('tag:yaml.org,2002:float', {
	  kind: 'scalar',
	  resolve: resolveYamlFloat,
	  construct: constructYamlFloat,
	  predicate: isFloat,
	  represent: representYamlFloat,
	  defaultStyle: 'lowercase'
	});
	return float;
}

var json;
var hasRequiredJson;

function requireJson () {
	if (hasRequiredJson) return json;
	hasRequiredJson = 1;


	json = requireFailsafe().extend({
	  implicit: [
	    require_null(),
	    requireBool(),
	    requireInt(),
	    requireFloat()
	  ]
	});
	return json;
}

var core;
var hasRequiredCore;

function requireCore () {
	if (hasRequiredCore) return core;
	hasRequiredCore = 1;


	core = requireJson();
	return core;
}

var timestamp;
var hasRequiredTimestamp;

function requireTimestamp () {
	if (hasRequiredTimestamp) return timestamp;
	hasRequiredTimestamp = 1;

	var Type = requireType();

	var YAML_DATE_REGEXP = new RegExp(
	  '^([0-9][0-9][0-9][0-9])'          + // [1] year
	  '-([0-9][0-9])'                    + // [2] month
	  '-([0-9][0-9])$');                   // [3] day

	var YAML_TIMESTAMP_REGEXP = new RegExp(
	  '^([0-9][0-9][0-9][0-9])'          + // [1] year
	  '-([0-9][0-9]?)'                   + // [2] month
	  '-([0-9][0-9]?)'                   + // [3] day
	  '(?:[Tt]|[ \\t]+)'                 + // ...
	  '([0-9][0-9]?)'                    + // [4] hour
	  ':([0-9][0-9])'                    + // [5] minute
	  ':([0-9][0-9])'                    + // [6] second
	  '(?:\\.([0-9]*))?'                 + // [7] fraction
	  '(?:[ \\t]*(Z|([-+])([0-9][0-9]?)' + // [8] tz [9] tz_sign [10] tz_hour
	  '(?::([0-9][0-9]))?))?$');           // [11] tz_minute

	function resolveYamlTimestamp(data) {
	  if (data === null) return false;
	  if (YAML_DATE_REGEXP.exec(data) !== null) return true;
	  if (YAML_TIMESTAMP_REGEXP.exec(data) !== null) return true;
	  return false;
	}

	function constructYamlTimestamp(data) {
	  var match, year, month, day, hour, minute, second, fraction = 0,
	      delta = null, tz_hour, tz_minute, date;

	  match = YAML_DATE_REGEXP.exec(data);
	  if (match === null) match = YAML_TIMESTAMP_REGEXP.exec(data);

	  if (match === null) throw new Error('Date resolve error');

	  // match: [1] year [2] month [3] day

	  year = +(match[1]);
	  month = +(match[2]) - 1; // JS month starts with 0
	  day = +(match[3]);

	  if (!match[4]) { // no hour
	    return new Date(Date.UTC(year, month, day));
	  }

	  // match: [4] hour [5] minute [6] second [7] fraction

	  hour = +(match[4]);
	  minute = +(match[5]);
	  second = +(match[6]);

	  if (match[7]) {
	    fraction = match[7].slice(0, 3);
	    while (fraction.length < 3) { // milli-seconds
	      fraction += '0';
	    }
	    fraction = +fraction;
	  }

	  // match: [8] tz [9] tz_sign [10] tz_hour [11] tz_minute

	  if (match[9]) {
	    tz_hour = +(match[10]);
	    tz_minute = +(match[11] || 0);
	    delta = (tz_hour * 60 + tz_minute) * 60000; // delta in mili-seconds
	    if (match[9] === '-') delta = -delta;
	  }

	  date = new Date(Date.UTC(year, month, day, hour, minute, second, fraction));

	  if (delta) date.setTime(date.getTime() - delta);

	  return date;
	}

	function representYamlTimestamp(object /*, style*/) {
	  return object.toISOString();
	}

	timestamp = new Type('tag:yaml.org,2002:timestamp', {
	  kind: 'scalar',
	  resolve: resolveYamlTimestamp,
	  construct: constructYamlTimestamp,
	  instanceOf: Date,
	  represent: representYamlTimestamp
	});
	return timestamp;
}

var merge;
var hasRequiredMerge;

function requireMerge () {
	if (hasRequiredMerge) return merge;
	hasRequiredMerge = 1;

	var Type = requireType();

	function resolveYamlMerge(data) {
	  return data === '<<' || data === null;
	}

	merge = new Type('tag:yaml.org,2002:merge', {
	  kind: 'scalar',
	  resolve: resolveYamlMerge
	});
	return merge;
}

var binary;
var hasRequiredBinary;

function requireBinary () {
	if (hasRequiredBinary) return binary;
	hasRequiredBinary = 1;

	/*eslint-disable no-bitwise*/


	var Type = requireType();


	// [ 64, 65, 66 ] -> [ padding, CR, LF ]
	var BASE64_MAP = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=\n\r';


	function resolveYamlBinary(data) {
	  if (data === null) return false;

	  var code, idx, bitlen = 0, max = data.length, map = BASE64_MAP;

	  // Convert one by one.
	  for (idx = 0; idx < max; idx++) {
	    code = map.indexOf(data.charAt(idx));

	    // Skip CR/LF
	    if (code > 64) continue;

	    // Fail on illegal characters
	    if (code < 0) return false;

	    bitlen += 6;
	  }

	  // If there are any bits left, source was corrupted
	  return (bitlen % 8) === 0;
	}

	function constructYamlBinary(data) {
	  var idx, tailbits,
	      input = data.replace(/[\r\n=]/g, ''), // remove CR/LF & padding to simplify scan
	      max = input.length,
	      map = BASE64_MAP,
	      bits = 0,
	      result = [];

	  // Collect by 6*4 bits (3 bytes)

	  for (idx = 0; idx < max; idx++) {
	    if ((idx % 4 === 0) && idx) {
	      result.push((bits >> 16) & 0xFF);
	      result.push((bits >> 8) & 0xFF);
	      result.push(bits & 0xFF);
	    }

	    bits = (bits << 6) | map.indexOf(input.charAt(idx));
	  }

	  // Dump tail

	  tailbits = (max % 4) * 6;

	  if (tailbits === 0) {
	    result.push((bits >> 16) & 0xFF);
	    result.push((bits >> 8) & 0xFF);
	    result.push(bits & 0xFF);
	  } else if (tailbits === 18) {
	    result.push((bits >> 10) & 0xFF);
	    result.push((bits >> 2) & 0xFF);
	  } else if (tailbits === 12) {
	    result.push((bits >> 4) & 0xFF);
	  }

	  return new Uint8Array(result);
	}

	function representYamlBinary(object /*, style*/) {
	  var result = '', bits = 0, idx, tail,
	      max = object.length,
	      map = BASE64_MAP;

	  // Convert every three bytes to 4 ASCII characters.

	  for (idx = 0; idx < max; idx++) {
	    if ((idx % 3 === 0) && idx) {
	      result += map[(bits >> 18) & 0x3F];
	      result += map[(bits >> 12) & 0x3F];
	      result += map[(bits >> 6) & 0x3F];
	      result += map[bits & 0x3F];
	    }

	    bits = (bits << 8) + object[idx];
	  }

	  // Dump tail

	  tail = max % 3;

	  if (tail === 0) {
	    result += map[(bits >> 18) & 0x3F];
	    result += map[(bits >> 12) & 0x3F];
	    result += map[(bits >> 6) & 0x3F];
	    result += map[bits & 0x3F];
	  } else if (tail === 2) {
	    result += map[(bits >> 10) & 0x3F];
	    result += map[(bits >> 4) & 0x3F];
	    result += map[(bits << 2) & 0x3F];
	    result += map[64];
	  } else if (tail === 1) {
	    result += map[(bits >> 2) & 0x3F];
	    result += map[(bits << 4) & 0x3F];
	    result += map[64];
	    result += map[64];
	  }

	  return result;
	}

	function isBinary(obj) {
	  return Object.prototype.toString.call(obj) ===  '[object Uint8Array]';
	}

	binary = new Type('tag:yaml.org,2002:binary', {
	  kind: 'scalar',
	  resolve: resolveYamlBinary,
	  construct: constructYamlBinary,
	  predicate: isBinary,
	  represent: representYamlBinary
	});
	return binary;
}

var omap;
var hasRequiredOmap;

function requireOmap () {
	if (hasRequiredOmap) return omap;
	hasRequiredOmap = 1;

	var Type = requireType();

	var _hasOwnProperty = Object.prototype.hasOwnProperty;
	var _toString       = Object.prototype.toString;

	function resolveYamlOmap(data) {
	  if (data === null) return true;

	  var objectKeys = [], index, length, pair, pairKey, pairHasKey,
	      object = data;

	  for (index = 0, length = object.length; index < length; index += 1) {
	    pair = object[index];
	    pairHasKey = false;

	    if (_toString.call(pair) !== '[object Object]') return false;

	    for (pairKey in pair) {
	      if (_hasOwnProperty.call(pair, pairKey)) {
	        if (!pairHasKey) pairHasKey = true;
	        else return false;
	      }
	    }

	    if (!pairHasKey) return false;

	    if (objectKeys.indexOf(pairKey) === -1) objectKeys.push(pairKey);
	    else return false;
	  }

	  return true;
	}

	function constructYamlOmap(data) {
	  return data !== null ? data : [];
	}

	omap = new Type('tag:yaml.org,2002:omap', {
	  kind: 'sequence',
	  resolve: resolveYamlOmap,
	  construct: constructYamlOmap
	});
	return omap;
}

var pairs;
var hasRequiredPairs;

function requirePairs () {
	if (hasRequiredPairs) return pairs;
	hasRequiredPairs = 1;

	var Type = requireType();

	var _toString = Object.prototype.toString;

	function resolveYamlPairs(data) {
	  if (data === null) return true;

	  var index, length, pair, keys, result,
	      object = data;

	  result = new Array(object.length);

	  for (index = 0, length = object.length; index < length; index += 1) {
	    pair = object[index];

	    if (_toString.call(pair) !== '[object Object]') return false;

	    keys = Object.keys(pair);

	    if (keys.length !== 1) return false;

	    result[index] = [ keys[0], pair[keys[0]] ];
	  }

	  return true;
	}

	function constructYamlPairs(data) {
	  if (data === null) return [];

	  var index, length, pair, keys, result,
	      object = data;

	  result = new Array(object.length);

	  for (index = 0, length = object.length; index < length; index += 1) {
	    pair = object[index];

	    keys = Object.keys(pair);

	    result[index] = [ keys[0], pair[keys[0]] ];
	  }

	  return result;
	}

	pairs = new Type('tag:yaml.org,2002:pairs', {
	  kind: 'sequence',
	  resolve: resolveYamlPairs,
	  construct: constructYamlPairs
	});
	return pairs;
}

var set;
var hasRequiredSet;

function requireSet () {
	if (hasRequiredSet) return set;
	hasRequiredSet = 1;

	var Type = requireType();

	var _hasOwnProperty = Object.prototype.hasOwnProperty;

	function resolveYamlSet(data) {
	  if (data === null) return true;

	  var key, object = data;

	  for (key in object) {
	    if (_hasOwnProperty.call(object, key)) {
	      if (object[key] !== null) return false;
	    }
	  }

	  return true;
	}

	function constructYamlSet(data) {
	  return data !== null ? data : {};
	}

	set = new Type('tag:yaml.org,2002:set', {
	  kind: 'mapping',
	  resolve: resolveYamlSet,
	  construct: constructYamlSet
	});
	return set;
}

var _default;
var hasRequired_default;

function require_default () {
	if (hasRequired_default) return _default;
	hasRequired_default = 1;


	_default = requireCore().extend({
	  implicit: [
	    requireTimestamp(),
	    requireMerge()
	  ],
	  explicit: [
	    requireBinary(),
	    requireOmap(),
	    requirePairs(),
	    requireSet()
	  ]
	});
	return _default;
}

var hasRequiredLoader;

function requireLoader () {
	if (hasRequiredLoader) return loader;
	hasRequiredLoader = 1;

	/*eslint-disable max-len,no-use-before-define*/

	var common              = requireCommon();
	var YAMLException       = requireException();
	var makeSnippet         = requireSnippet();
	var DEFAULT_SCHEMA      = require_default();


	var _hasOwnProperty = Object.prototype.hasOwnProperty;


	var CONTEXT_FLOW_IN   = 1;
	var CONTEXT_FLOW_OUT  = 2;
	var CONTEXT_BLOCK_IN  = 3;
	var CONTEXT_BLOCK_OUT = 4;


	var CHOMPING_CLIP  = 1;
	var CHOMPING_STRIP = 2;
	var CHOMPING_KEEP  = 3;


	var PATTERN_NON_PRINTABLE         = /[\x00-\x08\x0B\x0C\x0E-\x1F\x7F-\x84\x86-\x9F\uFFFE\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/;
	var PATTERN_NON_ASCII_LINE_BREAKS = /[\x85\u2028\u2029]/;
	var PATTERN_FLOW_INDICATORS       = /[,\[\]\{\}]/;
	var PATTERN_TAG_HANDLE            = /^(?:!|!!|![a-z\-]+!)$/i;
	var PATTERN_TAG_URI               = /^(?:!|[^,\[\]\{\}])(?:%[0-9a-f]{2}|[0-9a-z\-#;\/\?:@&=\+\$,_\.!~\*'\(\)\[\]])*$/i;


	function _class(obj) { return Object.prototype.toString.call(obj); }

	function is_EOL(c) {
	  return (c === 0x0A/* LF */) || (c === 0x0D/* CR */);
	}

	function is_WHITE_SPACE(c) {
	  return (c === 0x09/* Tab */) || (c === 0x20/* Space */);
	}

	function is_WS_OR_EOL(c) {
	  return (c === 0x09/* Tab */) ||
	         (c === 0x20/* Space */) ||
	         (c === 0x0A/* LF */) ||
	         (c === 0x0D/* CR */);
	}

	function is_FLOW_INDICATOR(c) {
	  return c === 0x2C/* , */ ||
	         c === 0x5B/* [ */ ||
	         c === 0x5D/* ] */ ||
	         c === 0x7B/* { */ ||
	         c === 0x7D/* } */;
	}

	function fromHexCode(c) {
	  var lc;

	  if ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */)) {
	    return c - 0x30;
	  }

	  /*eslint-disable no-bitwise*/
	  lc = c | 0x20;

	  if ((0x61/* a */ <= lc) && (lc <= 0x66/* f */)) {
	    return lc - 0x61 + 10;
	  }

	  return -1;
	}

	function escapedHexLen(c) {
	  if (c === 0x78/* x */) { return 2; }
	  if (c === 0x75/* u */) { return 4; }
	  if (c === 0x55/* U */) { return 8; }
	  return 0;
	}

	function fromDecimalCode(c) {
	  if ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */)) {
	    return c - 0x30;
	  }

	  return -1;
	}

	function simpleEscapeSequence(c) {
	  /* eslint-disable indent */
	  return (c === 0x30/* 0 */) ? '\x00' :
	        (c === 0x61/* a */) ? '\x07' :
	        (c === 0x62/* b */) ? '\x08' :
	        (c === 0x74/* t */) ? '\x09' :
	        (c === 0x09/* Tab */) ? '\x09' :
	        (c === 0x6E/* n */) ? '\x0A' :
	        (c === 0x76/* v */) ? '\x0B' :
	        (c === 0x66/* f */) ? '\x0C' :
	        (c === 0x72/* r */) ? '\x0D' :
	        (c === 0x65/* e */) ? '\x1B' :
	        (c === 0x20/* Space */) ? ' ' :
	        (c === 0x22/* " */) ? '\x22' :
	        (c === 0x2F/* / */) ? '/' :
	        (c === 0x5C/* \ */) ? '\x5C' :
	        (c === 0x4E/* N */) ? '\x85' :
	        (c === 0x5F/* _ */) ? '\xA0' :
	        (c === 0x4C/* L */) ? '\u2028' :
	        (c === 0x50/* P */) ? '\u2029' : '';
	}

	function charFromCodepoint(c) {
	  if (c <= 0xFFFF) {
	    return String.fromCharCode(c);
	  }
	  // Encode UTF-16 surrogate pair
	  // https://en.wikipedia.org/wiki/UTF-16#Code_points_U.2B010000_to_U.2B10FFFF
	  return String.fromCharCode(
	    ((c - 0x010000) >> 10) + 0xD800,
	    ((c - 0x010000) & 0x03FF) + 0xDC00
	  );
	}

	var simpleEscapeCheck = new Array(256); // integer, for fast access
	var simpleEscapeMap = new Array(256);
	for (var i = 0; i < 256; i++) {
	  simpleEscapeCheck[i] = simpleEscapeSequence(i) ? 1 : 0;
	  simpleEscapeMap[i] = simpleEscapeSequence(i);
	}


	function State(input, options) {
	  this.input = input;

	  this.filename  = options['filename']  || null;
	  this.schema    = options['schema']    || DEFAULT_SCHEMA;
	  this.onWarning = options['onWarning'] || null;
	  // (Hidden) Remove? makes the loader to expect YAML 1.1 documents
	  // if such documents have no explicit %YAML directive
	  this.legacy    = options['legacy']    || false;

	  this.json      = options['json']      || false;
	  this.listener  = options['listener']  || null;

	  this.implicitTypes = this.schema.compiledImplicit;
	  this.typeMap       = this.schema.compiledTypeMap;

	  this.length     = input.length;
	  this.position   = 0;
	  this.line       = 0;
	  this.lineStart  = 0;
	  this.lineIndent = 0;

	  // position of first leading tab in the current line,
	  // used to make sure there are no tabs in the indentation
	  this.firstTabInLine = -1;

	  this.documents = [];

	  /*
	  this.version;
	  this.checkLineBreaks;
	  this.tagMap;
	  this.anchorMap;
	  this.tag;
	  this.anchor;
	  this.kind;
	  this.result;*/

	}


	function generateError(state, message) {
	  var mark = {
	    name:     state.filename,
	    buffer:   state.input.slice(0, -1), // omit trailing \0
	    position: state.position,
	    line:     state.line,
	    column:   state.position - state.lineStart
	  };

	  mark.snippet = makeSnippet(mark);

	  return new YAMLException(message, mark);
	}

	function throwError(state, message) {
	  throw generateError(state, message);
	}

	function throwWarning(state, message) {
	  if (state.onWarning) {
	    state.onWarning.call(null, generateError(state, message));
	  }
	}


	var directiveHandlers = {

	  YAML: function handleYamlDirective(state, name, args) {

	    var match, major, minor;

	    if (state.version !== null) {
	      throwError(state, 'duplication of %YAML directive');
	    }

	    if (args.length !== 1) {
	      throwError(state, 'YAML directive accepts exactly one argument');
	    }

	    match = /^([0-9]+)\.([0-9]+)$/.exec(args[0]);

	    if (match === null) {
	      throwError(state, 'ill-formed argument of the YAML directive');
	    }

	    major = parseInt(match[1], 10);
	    minor = parseInt(match[2], 10);

	    if (major !== 1) {
	      throwError(state, 'unacceptable YAML version of the document');
	    }

	    state.version = args[0];
	    state.checkLineBreaks = (minor < 2);

	    if (minor !== 1 && minor !== 2) {
	      throwWarning(state, 'unsupported YAML version of the document');
	    }
	  },

	  TAG: function handleTagDirective(state, name, args) {

	    var handle, prefix;

	    if (args.length !== 2) {
	      throwError(state, 'TAG directive accepts exactly two arguments');
	    }

	    handle = args[0];
	    prefix = args[1];

	    if (!PATTERN_TAG_HANDLE.test(handle)) {
	      throwError(state, 'ill-formed tag handle (first argument) of the TAG directive');
	    }

	    if (_hasOwnProperty.call(state.tagMap, handle)) {
	      throwError(state, 'there is a previously declared suffix for "' + handle + '" tag handle');
	    }

	    if (!PATTERN_TAG_URI.test(prefix)) {
	      throwError(state, 'ill-formed tag prefix (second argument) of the TAG directive');
	    }

	    try {
	      prefix = decodeURIComponent(prefix);
	    } catch (err) {
	      throwError(state, 'tag prefix is malformed: ' + prefix);
	    }

	    state.tagMap[handle] = prefix;
	  }
	};


	function captureSegment(state, start, end, checkJson) {
	  var _position, _length, _character, _result;

	  if (start < end) {
	    _result = state.input.slice(start, end);

	    if (checkJson) {
	      for (_position = 0, _length = _result.length; _position < _length; _position += 1) {
	        _character = _result.charCodeAt(_position);
	        if (!(_character === 0x09 ||
	              (0x20 <= _character && _character <= 0x10FFFF))) {
	          throwError(state, 'expected valid JSON character');
	        }
	      }
	    } else if (PATTERN_NON_PRINTABLE.test(_result)) {
	      throwError(state, 'the stream contains non-printable characters');
	    }

	    state.result += _result;
	  }
	}

	function mergeMappings(state, destination, source, overridableKeys) {
	  var sourceKeys, key, index, quantity;

	  if (!common.isObject(source)) {
	    throwError(state, 'cannot merge mappings; the provided source object is unacceptable');
	  }

	  sourceKeys = Object.keys(source);

	  for (index = 0, quantity = sourceKeys.length; index < quantity; index += 1) {
	    key = sourceKeys[index];

	    if (!_hasOwnProperty.call(destination, key)) {
	      destination[key] = source[key];
	      overridableKeys[key] = true;
	    }
	  }
	}

	function storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode,
	  startLine, startLineStart, startPos) {

	  var index, quantity;

	  // The output is a plain object here, so keys can only be strings.
	  // We need to convert keyNode to a string, but doing so can hang the process
	  // (deeply nested arrays that explode exponentially using aliases).
	  if (Array.isArray(keyNode)) {
	    keyNode = Array.prototype.slice.call(keyNode);

	    for (index = 0, quantity = keyNode.length; index < quantity; index += 1) {
	      if (Array.isArray(keyNode[index])) {
	        throwError(state, 'nested arrays are not supported inside keys');
	      }

	      if (typeof keyNode === 'object' && _class(keyNode[index]) === '[object Object]') {
	        keyNode[index] = '[object Object]';
	      }
	    }
	  }

	  // Avoid code execution in load() via toString property
	  // (still use its own toString for arrays, timestamps,
	  // and whatever user schema extensions happen to have @@toStringTag)
	  if (typeof keyNode === 'object' && _class(keyNode) === '[object Object]') {
	    keyNode = '[object Object]';
	  }


	  keyNode = String(keyNode);

	  if (_result === null) {
	    _result = {};
	  }

	  if (keyTag === 'tag:yaml.org,2002:merge') {
	    if (Array.isArray(valueNode)) {
	      for (index = 0, quantity = valueNode.length; index < quantity; index += 1) {
	        mergeMappings(state, _result, valueNode[index], overridableKeys);
	      }
	    } else {
	      mergeMappings(state, _result, valueNode, overridableKeys);
	    }
	  } else {
	    if (!state.json &&
	        !_hasOwnProperty.call(overridableKeys, keyNode) &&
	        _hasOwnProperty.call(_result, keyNode)) {
	      state.line = startLine || state.line;
	      state.lineStart = startLineStart || state.lineStart;
	      state.position = startPos || state.position;
	      throwError(state, 'duplicated mapping key');
	    }

	    // used for this specific key only because Object.defineProperty is slow
	    if (keyNode === '__proto__') {
	      Object.defineProperty(_result, keyNode, {
	        configurable: true,
	        enumerable: true,
	        writable: true,
	        value: valueNode
	      });
	    } else {
	      _result[keyNode] = valueNode;
	    }
	    delete overridableKeys[keyNode];
	  }

	  return _result;
	}

	function readLineBreak(state) {
	  var ch;

	  ch = state.input.charCodeAt(state.position);

	  if (ch === 0x0A/* LF */) {
	    state.position++;
	  } else if (ch === 0x0D/* CR */) {
	    state.position++;
	    if (state.input.charCodeAt(state.position) === 0x0A/* LF */) {
	      state.position++;
	    }
	  } else {
	    throwError(state, 'a line break is expected');
	  }

	  state.line += 1;
	  state.lineStart = state.position;
	  state.firstTabInLine = -1;
	}

	function skipSeparationSpace(state, allowComments, checkIndent) {
	  var lineBreaks = 0,
	      ch = state.input.charCodeAt(state.position);

	  while (ch !== 0) {
	    while (is_WHITE_SPACE(ch)) {
	      if (ch === 0x09/* Tab */ && state.firstTabInLine === -1) {
	        state.firstTabInLine = state.position;
	      }
	      ch = state.input.charCodeAt(++state.position);
	    }

	    if (allowComments && ch === 0x23/* # */) {
	      do {
	        ch = state.input.charCodeAt(++state.position);
	      } while (ch !== 0x0A/* LF */ && ch !== 0x0D/* CR */ && ch !== 0);
	    }

	    if (is_EOL(ch)) {
	      readLineBreak(state);

	      ch = state.input.charCodeAt(state.position);
	      lineBreaks++;
	      state.lineIndent = 0;

	      while (ch === 0x20/* Space */) {
	        state.lineIndent++;
	        ch = state.input.charCodeAt(++state.position);
	      }
	    } else {
	      break;
	    }
	  }

	  if (checkIndent !== -1 && lineBreaks !== 0 && state.lineIndent < checkIndent) {
	    throwWarning(state, 'deficient indentation');
	  }

	  return lineBreaks;
	}

	function testDocumentSeparator(state) {
	  var _position = state.position,
	      ch;

	  ch = state.input.charCodeAt(_position);

	  // Condition state.position === state.lineStart is tested
	  // in parent on each call, for efficiency. No needs to test here again.
	  if ((ch === 0x2D/* - */ || ch === 0x2E/* . */) &&
	      ch === state.input.charCodeAt(_position + 1) &&
	      ch === state.input.charCodeAt(_position + 2)) {

	    _position += 3;

	    ch = state.input.charCodeAt(_position);

	    if (ch === 0 || is_WS_OR_EOL(ch)) {
	      return true;
	    }
	  }

	  return false;
	}

	function writeFoldedLines(state, count) {
	  if (count === 1) {
	    state.result += ' ';
	  } else if (count > 1) {
	    state.result += common.repeat('\n', count - 1);
	  }
	}


	function readPlainScalar(state, nodeIndent, withinFlowCollection) {
	  var preceding,
	      following,
	      captureStart,
	      captureEnd,
	      hasPendingContent,
	      _line,
	      _lineStart,
	      _lineIndent,
	      _kind = state.kind,
	      _result = state.result,
	      ch;

	  ch = state.input.charCodeAt(state.position);

	  if (is_WS_OR_EOL(ch)      ||
	      is_FLOW_INDICATOR(ch) ||
	      ch === 0x23/* # */    ||
	      ch === 0x26/* & */    ||
	      ch === 0x2A/* * */    ||
	      ch === 0x21/* ! */    ||
	      ch === 0x7C/* | */    ||
	      ch === 0x3E/* > */    ||
	      ch === 0x27/* ' */    ||
	      ch === 0x22/* " */    ||
	      ch === 0x25/* % */    ||
	      ch === 0x40/* @ */    ||
	      ch === 0x60/* ` */) {
	    return false;
	  }

	  if (ch === 0x3F/* ? */ || ch === 0x2D/* - */) {
	    following = state.input.charCodeAt(state.position + 1);

	    if (is_WS_OR_EOL(following) ||
	        withinFlowCollection && is_FLOW_INDICATOR(following)) {
	      return false;
	    }
	  }

	  state.kind = 'scalar';
	  state.result = '';
	  captureStart = captureEnd = state.position;
	  hasPendingContent = false;

	  while (ch !== 0) {
	    if (ch === 0x3A/* : */) {
	      following = state.input.charCodeAt(state.position + 1);

	      if (is_WS_OR_EOL(following) ||
	          withinFlowCollection && is_FLOW_INDICATOR(following)) {
	        break;
	      }

	    } else if (ch === 0x23/* # */) {
	      preceding = state.input.charCodeAt(state.position - 1);

	      if (is_WS_OR_EOL(preceding)) {
	        break;
	      }

	    } else if ((state.position === state.lineStart && testDocumentSeparator(state)) ||
	               withinFlowCollection && is_FLOW_INDICATOR(ch)) {
	      break;

	    } else if (is_EOL(ch)) {
	      _line = state.line;
	      _lineStart = state.lineStart;
	      _lineIndent = state.lineIndent;
	      skipSeparationSpace(state, false, -1);

	      if (state.lineIndent >= nodeIndent) {
	        hasPendingContent = true;
	        ch = state.input.charCodeAt(state.position);
	        continue;
	      } else {
	        state.position = captureEnd;
	        state.line = _line;
	        state.lineStart = _lineStart;
	        state.lineIndent = _lineIndent;
	        break;
	      }
	    }

	    if (hasPendingContent) {
	      captureSegment(state, captureStart, captureEnd, false);
	      writeFoldedLines(state, state.line - _line);
	      captureStart = captureEnd = state.position;
	      hasPendingContent = false;
	    }

	    if (!is_WHITE_SPACE(ch)) {
	      captureEnd = state.position + 1;
	    }

	    ch = state.input.charCodeAt(++state.position);
	  }

	  captureSegment(state, captureStart, captureEnd, false);

	  if (state.result) {
	    return true;
	  }

	  state.kind = _kind;
	  state.result = _result;
	  return false;
	}

	function readSingleQuotedScalar(state, nodeIndent) {
	  var ch,
	      captureStart, captureEnd;

	  ch = state.input.charCodeAt(state.position);

	  if (ch !== 0x27/* ' */) {
	    return false;
	  }

	  state.kind = 'scalar';
	  state.result = '';
	  state.position++;
	  captureStart = captureEnd = state.position;

	  while ((ch = state.input.charCodeAt(state.position)) !== 0) {
	    if (ch === 0x27/* ' */) {
	      captureSegment(state, captureStart, state.position, true);
	      ch = state.input.charCodeAt(++state.position);

	      if (ch === 0x27/* ' */) {
	        captureStart = state.position;
	        state.position++;
	        captureEnd = state.position;
	      } else {
	        return true;
	      }

	    } else if (is_EOL(ch)) {
	      captureSegment(state, captureStart, captureEnd, true);
	      writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent));
	      captureStart = captureEnd = state.position;

	    } else if (state.position === state.lineStart && testDocumentSeparator(state)) {
	      throwError(state, 'unexpected end of the document within a single quoted scalar');

	    } else {
	      state.position++;
	      captureEnd = state.position;
	    }
	  }

	  throwError(state, 'unexpected end of the stream within a single quoted scalar');
	}

	function readDoubleQuotedScalar(state, nodeIndent) {
	  var captureStart,
	      captureEnd,
	      hexLength,
	      hexResult,
	      tmp,
	      ch;

	  ch = state.input.charCodeAt(state.position);

	  if (ch !== 0x22/* " */) {
	    return false;
	  }

	  state.kind = 'scalar';
	  state.result = '';
	  state.position++;
	  captureStart = captureEnd = state.position;

	  while ((ch = state.input.charCodeAt(state.position)) !== 0) {
	    if (ch === 0x22/* " */) {
	      captureSegment(state, captureStart, state.position, true);
	      state.position++;
	      return true;

	    } else if (ch === 0x5C/* \ */) {
	      captureSegment(state, captureStart, state.position, true);
	      ch = state.input.charCodeAt(++state.position);

	      if (is_EOL(ch)) {
	        skipSeparationSpace(state, false, nodeIndent);

	        // TODO: rework to inline fn with no type cast?
	      } else if (ch < 256 && simpleEscapeCheck[ch]) {
	        state.result += simpleEscapeMap[ch];
	        state.position++;

	      } else if ((tmp = escapedHexLen(ch)) > 0) {
	        hexLength = tmp;
	        hexResult = 0;

	        for (; hexLength > 0; hexLength--) {
	          ch = state.input.charCodeAt(++state.position);

	          if ((tmp = fromHexCode(ch)) >= 0) {
	            hexResult = (hexResult << 4) + tmp;

	          } else {
	            throwError(state, 'expected hexadecimal character');
	          }
	        }

	        state.result += charFromCodepoint(hexResult);

	        state.position++;

	      } else {
	        throwError(state, 'unknown escape sequence');
	      }

	      captureStart = captureEnd = state.position;

	    } else if (is_EOL(ch)) {
	      captureSegment(state, captureStart, captureEnd, true);
	      writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent));
	      captureStart = captureEnd = state.position;

	    } else if (state.position === state.lineStart && testDocumentSeparator(state)) {
	      throwError(state, 'unexpected end of the document within a double quoted scalar');

	    } else {
	      state.position++;
	      captureEnd = state.position;
	    }
	  }

	  throwError(state, 'unexpected end of the stream within a double quoted scalar');
	}

	function readFlowCollection(state, nodeIndent) {
	  var readNext = true,
	      _line,
	      _lineStart,
	      _pos,
	      _tag     = state.tag,
	      _result,
	      _anchor  = state.anchor,
	      following,
	      terminator,
	      isPair,
	      isExplicitPair,
	      isMapping,
	      overridableKeys = Object.create(null),
	      keyNode,
	      keyTag,
	      valueNode,
	      ch;

	  ch = state.input.charCodeAt(state.position);

	  if (ch === 0x5B/* [ */) {
	    terminator = 0x5D;/* ] */
	    isMapping = false;
	    _result = [];
	  } else if (ch === 0x7B/* { */) {
	    terminator = 0x7D;/* } */
	    isMapping = true;
	    _result = {};
	  } else {
	    return false;
	  }

	  if (state.anchor !== null) {
	    state.anchorMap[state.anchor] = _result;
	  }

	  ch = state.input.charCodeAt(++state.position);

	  while (ch !== 0) {
	    skipSeparationSpace(state, true, nodeIndent);

	    ch = state.input.charCodeAt(state.position);

	    if (ch === terminator) {
	      state.position++;
	      state.tag = _tag;
	      state.anchor = _anchor;
	      state.kind = isMapping ? 'mapping' : 'sequence';
	      state.result = _result;
	      return true;
	    } else if (!readNext) {
	      throwError(state, 'missed comma between flow collection entries');
	    } else if (ch === 0x2C/* , */) {
	      // "flow collection entries can never be completely empty", as per YAML 1.2, section 7.4
	      throwError(state, "expected the node content, but found ','");
	    }

	    keyTag = keyNode = valueNode = null;
	    isPair = isExplicitPair = false;

	    if (ch === 0x3F/* ? */) {
	      following = state.input.charCodeAt(state.position + 1);

	      if (is_WS_OR_EOL(following)) {
	        isPair = isExplicitPair = true;
	        state.position++;
	        skipSeparationSpace(state, true, nodeIndent);
	      }
	    }

	    _line = state.line; // Save the current line.
	    _lineStart = state.lineStart;
	    _pos = state.position;
	    composeNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true);
	    keyTag = state.tag;
	    keyNode = state.result;
	    skipSeparationSpace(state, true, nodeIndent);

	    ch = state.input.charCodeAt(state.position);

	    if ((isExplicitPair || state.line === _line) && ch === 0x3A/* : */) {
	      isPair = true;
	      ch = state.input.charCodeAt(++state.position);
	      skipSeparationSpace(state, true, nodeIndent);
	      composeNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true);
	      valueNode = state.result;
	    }

	    if (isMapping) {
	      storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, _line, _lineStart, _pos);
	    } else if (isPair) {
	      _result.push(storeMappingPair(state, null, overridableKeys, keyTag, keyNode, valueNode, _line, _lineStart, _pos));
	    } else {
	      _result.push(keyNode);
	    }

	    skipSeparationSpace(state, true, nodeIndent);

	    ch = state.input.charCodeAt(state.position);

	    if (ch === 0x2C/* , */) {
	      readNext = true;
	      ch = state.input.charCodeAt(++state.position);
	    } else {
	      readNext = false;
	    }
	  }

	  throwError(state, 'unexpected end of the stream within a flow collection');
	}

	function readBlockScalar(state, nodeIndent) {
	  var captureStart,
	      folding,
	      chomping       = CHOMPING_CLIP,
	      didReadContent = false,
	      detectedIndent = false,
	      textIndent     = nodeIndent,
	      emptyLines     = 0,
	      atMoreIndented = false,
	      tmp,
	      ch;

	  ch = state.input.charCodeAt(state.position);

	  if (ch === 0x7C/* | */) {
	    folding = false;
	  } else if (ch === 0x3E/* > */) {
	    folding = true;
	  } else {
	    return false;
	  }

	  state.kind = 'scalar';
	  state.result = '';

	  while (ch !== 0) {
	    ch = state.input.charCodeAt(++state.position);

	    if (ch === 0x2B/* + */ || ch === 0x2D/* - */) {
	      if (CHOMPING_CLIP === chomping) {
	        chomping = (ch === 0x2B/* + */) ? CHOMPING_KEEP : CHOMPING_STRIP;
	      } else {
	        throwError(state, 'repeat of a chomping mode identifier');
	      }

	    } else if ((tmp = fromDecimalCode(ch)) >= 0) {
	      if (tmp === 0) {
	        throwError(state, 'bad explicit indentation width of a block scalar; it cannot be less than one');
	      } else if (!detectedIndent) {
	        textIndent = nodeIndent + tmp - 1;
	        detectedIndent = true;
	      } else {
	        throwError(state, 'repeat of an indentation width identifier');
	      }

	    } else {
	      break;
	    }
	  }

	  if (is_WHITE_SPACE(ch)) {
	    do { ch = state.input.charCodeAt(++state.position); }
	    while (is_WHITE_SPACE(ch));

	    if (ch === 0x23/* # */) {
	      do { ch = state.input.charCodeAt(++state.position); }
	      while (!is_EOL(ch) && (ch !== 0));
	    }
	  }

	  while (ch !== 0) {
	    readLineBreak(state);
	    state.lineIndent = 0;

	    ch = state.input.charCodeAt(state.position);

	    while ((!detectedIndent || state.lineIndent < textIndent) &&
	           (ch === 0x20/* Space */)) {
	      state.lineIndent++;
	      ch = state.input.charCodeAt(++state.position);
	    }

	    if (!detectedIndent && state.lineIndent > textIndent) {
	      textIndent = state.lineIndent;
	    }

	    if (is_EOL(ch)) {
	      emptyLines++;
	      continue;
	    }

	    // End of the scalar.
	    if (state.lineIndent < textIndent) {

	      // Perform the chomping.
	      if (chomping === CHOMPING_KEEP) {
	        state.result += common.repeat('\n', didReadContent ? 1 + emptyLines : emptyLines);
	      } else if (chomping === CHOMPING_CLIP) {
	        if (didReadContent) { // i.e. only if the scalar is not empty.
	          state.result += '\n';
	        }
	      }

	      // Break this `while` cycle and go to the funciton's epilogue.
	      break;
	    }

	    // Folded style: use fancy rules to handle line breaks.
	    if (folding) {

	      // Lines starting with white space characters (more-indented lines) are not folded.
	      if (is_WHITE_SPACE(ch)) {
	        atMoreIndented = true;
	        // except for the first content line (cf. Example 8.1)
	        state.result += common.repeat('\n', didReadContent ? 1 + emptyLines : emptyLines);

	      // End of more-indented block.
	      } else if (atMoreIndented) {
	        atMoreIndented = false;
	        state.result += common.repeat('\n', emptyLines + 1);

	      // Just one line break - perceive as the same line.
	      } else if (emptyLines === 0) {
	        if (didReadContent) { // i.e. only if we have already read some scalar content.
	          state.result += ' ';
	        }

	      // Several line breaks - perceive as different lines.
	      } else {
	        state.result += common.repeat('\n', emptyLines);
	      }

	    // Literal style: just add exact number of line breaks between content lines.
	    } else {
	      // Keep all line breaks except the header line break.
	      state.result += common.repeat('\n', didReadContent ? 1 + emptyLines : emptyLines);
	    }

	    didReadContent = true;
	    detectedIndent = true;
	    emptyLines = 0;
	    captureStart = state.position;

	    while (!is_EOL(ch) && (ch !== 0)) {
	      ch = state.input.charCodeAt(++state.position);
	    }

	    captureSegment(state, captureStart, state.position, false);
	  }

	  return true;
	}

	function readBlockSequence(state, nodeIndent) {
	  var _line,
	      _tag      = state.tag,
	      _anchor   = state.anchor,
	      _result   = [],
	      following,
	      detected  = false,
	      ch;

	  // there is a leading tab before this token, so it can't be a block sequence/mapping;
	  // it can still be flow sequence/mapping or a scalar
	  if (state.firstTabInLine !== -1) return false;

	  if (state.anchor !== null) {
	    state.anchorMap[state.anchor] = _result;
	  }

	  ch = state.input.charCodeAt(state.position);

	  while (ch !== 0) {
	    if (state.firstTabInLine !== -1) {
	      state.position = state.firstTabInLine;
	      throwError(state, 'tab characters must not be used in indentation');
	    }

	    if (ch !== 0x2D/* - */) {
	      break;
	    }

	    following = state.input.charCodeAt(state.position + 1);

	    if (!is_WS_OR_EOL(following)) {
	      break;
	    }

	    detected = true;
	    state.position++;

	    if (skipSeparationSpace(state, true, -1)) {
	      if (state.lineIndent <= nodeIndent) {
	        _result.push(null);
	        ch = state.input.charCodeAt(state.position);
	        continue;
	      }
	    }

	    _line = state.line;
	    composeNode(state, nodeIndent, CONTEXT_BLOCK_IN, false, true);
	    _result.push(state.result);
	    skipSeparationSpace(state, true, -1);

	    ch = state.input.charCodeAt(state.position);

	    if ((state.line === _line || state.lineIndent > nodeIndent) && (ch !== 0)) {
	      throwError(state, 'bad indentation of a sequence entry');
	    } else if (state.lineIndent < nodeIndent) {
	      break;
	    }
	  }

	  if (detected) {
	    state.tag = _tag;
	    state.anchor = _anchor;
	    state.kind = 'sequence';
	    state.result = _result;
	    return true;
	  }
	  return false;
	}

	function readBlockMapping(state, nodeIndent, flowIndent) {
	  var following,
	      allowCompact,
	      _line,
	      _keyLine,
	      _keyLineStart,
	      _keyPos,
	      _tag          = state.tag,
	      _anchor       = state.anchor,
	      _result       = {},
	      overridableKeys = Object.create(null),
	      keyTag        = null,
	      keyNode       = null,
	      valueNode     = null,
	      atExplicitKey = false,
	      detected      = false,
	      ch;

	  // there is a leading tab before this token, so it can't be a block sequence/mapping;
	  // it can still be flow sequence/mapping or a scalar
	  if (state.firstTabInLine !== -1) return false;

	  if (state.anchor !== null) {
	    state.anchorMap[state.anchor] = _result;
	  }

	  ch = state.input.charCodeAt(state.position);

	  while (ch !== 0) {
	    if (!atExplicitKey && state.firstTabInLine !== -1) {
	      state.position = state.firstTabInLine;
	      throwError(state, 'tab characters must not be used in indentation');
	    }

	    following = state.input.charCodeAt(state.position + 1);
	    _line = state.line; // Save the current line.

	    //
	    // Explicit notation case. There are two separate blocks:
	    // first for the key (denoted by "?") and second for the value (denoted by ":")
	    //
	    if ((ch === 0x3F/* ? */ || ch === 0x3A/* : */) && is_WS_OR_EOL(following)) {

	      if (ch === 0x3F/* ? */) {
	        if (atExplicitKey) {
	          storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null, _keyLine, _keyLineStart, _keyPos);
	          keyTag = keyNode = valueNode = null;
	        }

	        detected = true;
	        atExplicitKey = true;
	        allowCompact = true;

	      } else if (atExplicitKey) {
	        // i.e. 0x3A/* : */ === character after the explicit key.
	        atExplicitKey = false;
	        allowCompact = true;

	      } else {
	        throwError(state, 'incomplete explicit mapping pair; a key node is missed; or followed by a non-tabulated empty line');
	      }

	      state.position += 1;
	      ch = following;

	    //
	    // Implicit notation case. Flow-style node as the key first, then ":", and the value.
	    //
	    } else {
	      _keyLine = state.line;
	      _keyLineStart = state.lineStart;
	      _keyPos = state.position;

	      if (!composeNode(state, flowIndent, CONTEXT_FLOW_OUT, false, true)) {
	        // Neither implicit nor explicit notation.
	        // Reading is done. Go to the epilogue.
	        break;
	      }

	      if (state.line === _line) {
	        ch = state.input.charCodeAt(state.position);

	        while (is_WHITE_SPACE(ch)) {
	          ch = state.input.charCodeAt(++state.position);
	        }

	        if (ch === 0x3A/* : */) {
	          ch = state.input.charCodeAt(++state.position);

	          if (!is_WS_OR_EOL(ch)) {
	            throwError(state, 'a whitespace character is expected after the key-value separator within a block mapping');
	          }

	          if (atExplicitKey) {
	            storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null, _keyLine, _keyLineStart, _keyPos);
	            keyTag = keyNode = valueNode = null;
	          }

	          detected = true;
	          atExplicitKey = false;
	          allowCompact = false;
	          keyTag = state.tag;
	          keyNode = state.result;

	        } else if (detected) {
	          throwError(state, 'can not read an implicit mapping pair; a colon is missed');

	        } else {
	          state.tag = _tag;
	          state.anchor = _anchor;
	          return true; // Keep the result of `composeNode`.
	        }

	      } else if (detected) {
	        throwError(state, 'can not read a block mapping entry; a multiline key may not be an implicit key');

	      } else {
	        state.tag = _tag;
	        state.anchor = _anchor;
	        return true; // Keep the result of `composeNode`.
	      }
	    }

	    //
	    // Common reading code for both explicit and implicit notations.
	    //
	    if (state.line === _line || state.lineIndent > nodeIndent) {
	      if (atExplicitKey) {
	        _keyLine = state.line;
	        _keyLineStart = state.lineStart;
	        _keyPos = state.position;
	      }

	      if (composeNode(state, nodeIndent, CONTEXT_BLOCK_OUT, true, allowCompact)) {
	        if (atExplicitKey) {
	          keyNode = state.result;
	        } else {
	          valueNode = state.result;
	        }
	      }

	      if (!atExplicitKey) {
	        storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, _keyLine, _keyLineStart, _keyPos);
	        keyTag = keyNode = valueNode = null;
	      }

	      skipSeparationSpace(state, true, -1);
	      ch = state.input.charCodeAt(state.position);
	    }

	    if ((state.line === _line || state.lineIndent > nodeIndent) && (ch !== 0)) {
	      throwError(state, 'bad indentation of a mapping entry');
	    } else if (state.lineIndent < nodeIndent) {
	      break;
	    }
	  }

	  //
	  // Epilogue.
	  //

	  // Special case: last mapping's node contains only the key in explicit notation.
	  if (atExplicitKey) {
	    storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null, _keyLine, _keyLineStart, _keyPos);
	  }

	  // Expose the resulting mapping.
	  if (detected) {
	    state.tag = _tag;
	    state.anchor = _anchor;
	    state.kind = 'mapping';
	    state.result = _result;
	  }

	  return detected;
	}

	function readTagProperty(state) {
	  var _position,
	      isVerbatim = false,
	      isNamed    = false,
	      tagHandle,
	      tagName,
	      ch;

	  ch = state.input.charCodeAt(state.position);

	  if (ch !== 0x21/* ! */) return false;

	  if (state.tag !== null) {
	    throwError(state, 'duplication of a tag property');
	  }

	  ch = state.input.charCodeAt(++state.position);

	  if (ch === 0x3C/* < */) {
	    isVerbatim = true;
	    ch = state.input.charCodeAt(++state.position);

	  } else if (ch === 0x21/* ! */) {
	    isNamed = true;
	    tagHandle = '!!';
	    ch = state.input.charCodeAt(++state.position);

	  } else {
	    tagHandle = '!';
	  }

	  _position = state.position;

	  if (isVerbatim) {
	    do { ch = state.input.charCodeAt(++state.position); }
	    while (ch !== 0 && ch !== 0x3E/* > */);

	    if (state.position < state.length) {
	      tagName = state.input.slice(_position, state.position);
	      ch = state.input.charCodeAt(++state.position);
	    } else {
	      throwError(state, 'unexpected end of the stream within a verbatim tag');
	    }
	  } else {
	    while (ch !== 0 && !is_WS_OR_EOL(ch)) {

	      if (ch === 0x21/* ! */) {
	        if (!isNamed) {
	          tagHandle = state.input.slice(_position - 1, state.position + 1);

	          if (!PATTERN_TAG_HANDLE.test(tagHandle)) {
	            throwError(state, 'named tag handle cannot contain such characters');
	          }

	          isNamed = true;
	          _position = state.position + 1;
	        } else {
	          throwError(state, 'tag suffix cannot contain exclamation marks');
	        }
	      }

	      ch = state.input.charCodeAt(++state.position);
	    }

	    tagName = state.input.slice(_position, state.position);

	    if (PATTERN_FLOW_INDICATORS.test(tagName)) {
	      throwError(state, 'tag suffix cannot contain flow indicator characters');
	    }
	  }

	  if (tagName && !PATTERN_TAG_URI.test(tagName)) {
	    throwError(state, 'tag name cannot contain such characters: ' + tagName);
	  }

	  try {
	    tagName = decodeURIComponent(tagName);
	  } catch (err) {
	    throwError(state, 'tag name is malformed: ' + tagName);
	  }

	  if (isVerbatim) {
	    state.tag = tagName;

	  } else if (_hasOwnProperty.call(state.tagMap, tagHandle)) {
	    state.tag = state.tagMap[tagHandle] + tagName;

	  } else if (tagHandle === '!') {
	    state.tag = '!' + tagName;

	  } else if (tagHandle === '!!') {
	    state.tag = 'tag:yaml.org,2002:' + tagName;

	  } else {
	    throwError(state, 'undeclared tag handle "' + tagHandle + '"');
	  }

	  return true;
	}

	function readAnchorProperty(state) {
	  var _position,
	      ch;

	  ch = state.input.charCodeAt(state.position);

	  if (ch !== 0x26/* & */) return false;

	  if (state.anchor !== null) {
	    throwError(state, 'duplication of an anchor property');
	  }

	  ch = state.input.charCodeAt(++state.position);
	  _position = state.position;

	  while (ch !== 0 && !is_WS_OR_EOL(ch) && !is_FLOW_INDICATOR(ch)) {
	    ch = state.input.charCodeAt(++state.position);
	  }

	  if (state.position === _position) {
	    throwError(state, 'name of an anchor node must contain at least one character');
	  }

	  state.anchor = state.input.slice(_position, state.position);
	  return true;
	}

	function readAlias(state) {
	  var _position, alias,
	      ch;

	  ch = state.input.charCodeAt(state.position);

	  if (ch !== 0x2A/* * */) return false;

	  ch = state.input.charCodeAt(++state.position);
	  _position = state.position;

	  while (ch !== 0 && !is_WS_OR_EOL(ch) && !is_FLOW_INDICATOR(ch)) {
	    ch = state.input.charCodeAt(++state.position);
	  }

	  if (state.position === _position) {
	    throwError(state, 'name of an alias node must contain at least one character');
	  }

	  alias = state.input.slice(_position, state.position);

	  if (!_hasOwnProperty.call(state.anchorMap, alias)) {
	    throwError(state, 'unidentified alias "' + alias + '"');
	  }

	  state.result = state.anchorMap[alias];
	  skipSeparationSpace(state, true, -1);
	  return true;
	}

	function composeNode(state, parentIndent, nodeContext, allowToSeek, allowCompact) {
	  var allowBlockStyles,
	      allowBlockScalars,
	      allowBlockCollections,
	      indentStatus = 1, // 1: this>parent, 0: this=parent, -1: this<parent
	      atNewLine  = false,
	      hasContent = false,
	      typeIndex,
	      typeQuantity,
	      typeList,
	      type,
	      flowIndent,
	      blockIndent;

	  if (state.listener !== null) {
	    state.listener('open', state);
	  }

	  state.tag    = null;
	  state.anchor = null;
	  state.kind   = null;
	  state.result = null;

	  allowBlockStyles = allowBlockScalars = allowBlockCollections =
	    CONTEXT_BLOCK_OUT === nodeContext ||
	    CONTEXT_BLOCK_IN  === nodeContext;

	  if (allowToSeek) {
	    if (skipSeparationSpace(state, true, -1)) {
	      atNewLine = true;

	      if (state.lineIndent > parentIndent) {
	        indentStatus = 1;
	      } else if (state.lineIndent === parentIndent) {
	        indentStatus = 0;
	      } else if (state.lineIndent < parentIndent) {
	        indentStatus = -1;
	      }
	    }
	  }

	  if (indentStatus === 1) {
	    while (readTagProperty(state) || readAnchorProperty(state)) {
	      if (skipSeparationSpace(state, true, -1)) {
	        atNewLine = true;
	        allowBlockCollections = allowBlockStyles;

	        if (state.lineIndent > parentIndent) {
	          indentStatus = 1;
	        } else if (state.lineIndent === parentIndent) {
	          indentStatus = 0;
	        } else if (state.lineIndent < parentIndent) {
	          indentStatus = -1;
	        }
	      } else {
	        allowBlockCollections = false;
	      }
	    }
	  }

	  if (allowBlockCollections) {
	    allowBlockCollections = atNewLine || allowCompact;
	  }

	  if (indentStatus === 1 || CONTEXT_BLOCK_OUT === nodeContext) {
	    if (CONTEXT_FLOW_IN === nodeContext || CONTEXT_FLOW_OUT === nodeContext) {
	      flowIndent = parentIndent;
	    } else {
	      flowIndent = parentIndent + 1;
	    }

	    blockIndent = state.position - state.lineStart;

	    if (indentStatus === 1) {
	      if (allowBlockCollections &&
	          (readBlockSequence(state, blockIndent) ||
	           readBlockMapping(state, blockIndent, flowIndent)) ||
	          readFlowCollection(state, flowIndent)) {
	        hasContent = true;
	      } else {
	        if ((allowBlockScalars && readBlockScalar(state, flowIndent)) ||
	            readSingleQuotedScalar(state, flowIndent) ||
	            readDoubleQuotedScalar(state, flowIndent)) {
	          hasContent = true;

	        } else if (readAlias(state)) {
	          hasContent = true;

	          if (state.tag !== null || state.anchor !== null) {
	            throwError(state, 'alias node should not have any properties');
	          }

	        } else if (readPlainScalar(state, flowIndent, CONTEXT_FLOW_IN === nodeContext)) {
	          hasContent = true;

	          if (state.tag === null) {
	            state.tag = '?';
	          }
	        }

	        if (state.anchor !== null) {
	          state.anchorMap[state.anchor] = state.result;
	        }
	      }
	    } else if (indentStatus === 0) {
	      // Special case: block sequences are allowed to have same indentation level as the parent.
	      // http://www.yaml.org/spec/1.2/spec.html#id2799784
	      hasContent = allowBlockCollections && readBlockSequence(state, blockIndent);
	    }
	  }

	  if (state.tag === null) {
	    if (state.anchor !== null) {
	      state.anchorMap[state.anchor] = state.result;
	    }

	  } else if (state.tag === '?') {
	    // Implicit resolving is not allowed for non-scalar types, and '?'
	    // non-specific tag is only automatically assigned to plain scalars.
	    //
	    // We only need to check kind conformity in case user explicitly assigns '?'
	    // tag, for example like this: "!<?> [0]"
	    //
	    if (state.result !== null && state.kind !== 'scalar') {
	      throwError(state, 'unacceptable node kind for !<?> tag; it should be "scalar", not "' + state.kind + '"');
	    }

	    for (typeIndex = 0, typeQuantity = state.implicitTypes.length; typeIndex < typeQuantity; typeIndex += 1) {
	      type = state.implicitTypes[typeIndex];

	      if (type.resolve(state.result)) { // `state.result` updated in resolver if matched
	        state.result = type.construct(state.result);
	        state.tag = type.tag;
	        if (state.anchor !== null) {
	          state.anchorMap[state.anchor] = state.result;
	        }
	        break;
	      }
	    }
	  } else if (state.tag !== '!') {
	    if (_hasOwnProperty.call(state.typeMap[state.kind || 'fallback'], state.tag)) {
	      type = state.typeMap[state.kind || 'fallback'][state.tag];
	    } else {
	      // looking for multi type
	      type = null;
	      typeList = state.typeMap.multi[state.kind || 'fallback'];

	      for (typeIndex = 0, typeQuantity = typeList.length; typeIndex < typeQuantity; typeIndex += 1) {
	        if (state.tag.slice(0, typeList[typeIndex].tag.length) === typeList[typeIndex].tag) {
	          type = typeList[typeIndex];
	          break;
	        }
	      }
	    }

	    if (!type) {
	      throwError(state, 'unknown tag !<' + state.tag + '>');
	    }

	    if (state.result !== null && type.kind !== state.kind) {
	      throwError(state, 'unacceptable node kind for !<' + state.tag + '> tag; it should be "' + type.kind + '", not "' + state.kind + '"');
	    }

	    if (!type.resolve(state.result, state.tag)) { // `state.result` updated in resolver if matched
	      throwError(state, 'cannot resolve a node with !<' + state.tag + '> explicit tag');
	    } else {
	      state.result = type.construct(state.result, state.tag);
	      if (state.anchor !== null) {
	        state.anchorMap[state.anchor] = state.result;
	      }
	    }
	  }

	  if (state.listener !== null) {
	    state.listener('close', state);
	  }
	  return state.tag !== null ||  state.anchor !== null || hasContent;
	}

	function readDocument(state) {
	  var documentStart = state.position,
	      _position,
	      directiveName,
	      directiveArgs,
	      hasDirectives = false,
	      ch;

	  state.version = null;
	  state.checkLineBreaks = state.legacy;
	  state.tagMap = Object.create(null);
	  state.anchorMap = Object.create(null);

	  while ((ch = state.input.charCodeAt(state.position)) !== 0) {
	    skipSeparationSpace(state, true, -1);

	    ch = state.input.charCodeAt(state.position);

	    if (state.lineIndent > 0 || ch !== 0x25/* % */) {
	      break;
	    }

	    hasDirectives = true;
	    ch = state.input.charCodeAt(++state.position);
	    _position = state.position;

	    while (ch !== 0 && !is_WS_OR_EOL(ch)) {
	      ch = state.input.charCodeAt(++state.position);
	    }

	    directiveName = state.input.slice(_position, state.position);
	    directiveArgs = [];

	    if (directiveName.length < 1) {
	      throwError(state, 'directive name must not be less than one character in length');
	    }

	    while (ch !== 0) {
	      while (is_WHITE_SPACE(ch)) {
	        ch = state.input.charCodeAt(++state.position);
	      }

	      if (ch === 0x23/* # */) {
	        do { ch = state.input.charCodeAt(++state.position); }
	        while (ch !== 0 && !is_EOL(ch));
	        break;
	      }

	      if (is_EOL(ch)) break;

	      _position = state.position;

	      while (ch !== 0 && !is_WS_OR_EOL(ch)) {
	        ch = state.input.charCodeAt(++state.position);
	      }

	      directiveArgs.push(state.input.slice(_position, state.position));
	    }

	    if (ch !== 0) readLineBreak(state);

	    if (_hasOwnProperty.call(directiveHandlers, directiveName)) {
	      directiveHandlers[directiveName](state, directiveName, directiveArgs);
	    } else {
	      throwWarning(state, 'unknown document directive "' + directiveName + '"');
	    }
	  }

	  skipSeparationSpace(state, true, -1);

	  if (state.lineIndent === 0 &&
	      state.input.charCodeAt(state.position)     === 0x2D/* - */ &&
	      state.input.charCodeAt(state.position + 1) === 0x2D/* - */ &&
	      state.input.charCodeAt(state.position + 2) === 0x2D/* - */) {
	    state.position += 3;
	    skipSeparationSpace(state, true, -1);

	  } else if (hasDirectives) {
	    throwError(state, 'directives end mark is expected');
	  }

	  composeNode(state, state.lineIndent - 1, CONTEXT_BLOCK_OUT, false, true);
	  skipSeparationSpace(state, true, -1);

	  if (state.checkLineBreaks &&
	      PATTERN_NON_ASCII_LINE_BREAKS.test(state.input.slice(documentStart, state.position))) {
	    throwWarning(state, 'non-ASCII line breaks are interpreted as content');
	  }

	  state.documents.push(state.result);

	  if (state.position === state.lineStart && testDocumentSeparator(state)) {

	    if (state.input.charCodeAt(state.position) === 0x2E/* . */) {
	      state.position += 3;
	      skipSeparationSpace(state, true, -1);
	    }
	    return;
	  }

	  if (state.position < (state.length - 1)) {
	    throwError(state, 'end of the stream or a document separator is expected');
	  } else {
	    return;
	  }
	}


	function loadDocuments(input, options) {
	  input = String(input);
	  options = options || {};

	  if (input.length !== 0) {

	    // Add tailing `\n` if not exists
	    if (input.charCodeAt(input.length - 1) !== 0x0A/* LF */ &&
	        input.charCodeAt(input.length - 1) !== 0x0D/* CR */) {
	      input += '\n';
	    }

	    // Strip BOM
	    if (input.charCodeAt(0) === 0xFEFF) {
	      input = input.slice(1);
	    }
	  }

	  var state = new State(input, options);

	  var nullpos = input.indexOf('\0');

	  if (nullpos !== -1) {
	    state.position = nullpos;
	    throwError(state, 'null byte is not allowed in input');
	  }

	  // Use 0 as string terminator. That significantly simplifies bounds check.
	  state.input += '\0';

	  while (state.input.charCodeAt(state.position) === 0x20/* Space */) {
	    state.lineIndent += 1;
	    state.position += 1;
	  }

	  while (state.position < (state.length - 1)) {
	    readDocument(state);
	  }

	  return state.documents;
	}


	function loadAll(input, iterator, options) {
	  if (iterator !== null && typeof iterator === 'object' && typeof options === 'undefined') {
	    options = iterator;
	    iterator = null;
	  }

	  var documents = loadDocuments(input, options);

	  if (typeof iterator !== 'function') {
	    return documents;
	  }

	  for (var index = 0, length = documents.length; index < length; index += 1) {
	    iterator(documents[index]);
	  }
	}


	function load(input, options) {
	  var documents = loadDocuments(input, options);

	  if (documents.length === 0) {
	    /*eslint-disable no-undefined*/
	    return undefined;
	  } else if (documents.length === 1) {
	    return documents[0];
	  }
	  throw new YAMLException('expected a single document in the stream, but found more');
	}


	loader.loadAll = loadAll;
	loader.load    = load;
	return loader;
}

var dumper = {};

var hasRequiredDumper;

function requireDumper () {
	if (hasRequiredDumper) return dumper;
	hasRequiredDumper = 1;

	/*eslint-disable no-use-before-define*/

	var common              = requireCommon();
	var YAMLException       = requireException();
	var DEFAULT_SCHEMA      = require_default();

	var _toString       = Object.prototype.toString;
	var _hasOwnProperty = Object.prototype.hasOwnProperty;

	var CHAR_BOM                  = 0xFEFF;
	var CHAR_TAB                  = 0x09; /* Tab */
	var CHAR_LINE_FEED            = 0x0A; /* LF */
	var CHAR_CARRIAGE_RETURN      = 0x0D; /* CR */
	var CHAR_SPACE                = 0x20; /* Space */
	var CHAR_EXCLAMATION          = 0x21; /* ! */
	var CHAR_DOUBLE_QUOTE         = 0x22; /* " */
	var CHAR_SHARP                = 0x23; /* # */
	var CHAR_PERCENT              = 0x25; /* % */
	var CHAR_AMPERSAND            = 0x26; /* & */
	var CHAR_SINGLE_QUOTE         = 0x27; /* ' */
	var CHAR_ASTERISK             = 0x2A; /* * */
	var CHAR_COMMA                = 0x2C; /* , */
	var CHAR_MINUS                = 0x2D; /* - */
	var CHAR_COLON                = 0x3A; /* : */
	var CHAR_EQUALS               = 0x3D; /* = */
	var CHAR_GREATER_THAN         = 0x3E; /* > */
	var CHAR_QUESTION             = 0x3F; /* ? */
	var CHAR_COMMERCIAL_AT        = 0x40; /* @ */
	var CHAR_LEFT_SQUARE_BRACKET  = 0x5B; /* [ */
	var CHAR_RIGHT_SQUARE_BRACKET = 0x5D; /* ] */
	var CHAR_GRAVE_ACCENT         = 0x60; /* ` */
	var CHAR_LEFT_CURLY_BRACKET   = 0x7B; /* { */
	var CHAR_VERTICAL_LINE        = 0x7C; /* | */
	var CHAR_RIGHT_CURLY_BRACKET  = 0x7D; /* } */

	var ESCAPE_SEQUENCES = {};

	ESCAPE_SEQUENCES[0x00]   = '\\0';
	ESCAPE_SEQUENCES[0x07]   = '\\a';
	ESCAPE_SEQUENCES[0x08]   = '\\b';
	ESCAPE_SEQUENCES[0x09]   = '\\t';
	ESCAPE_SEQUENCES[0x0A]   = '\\n';
	ESCAPE_SEQUENCES[0x0B]   = '\\v';
	ESCAPE_SEQUENCES[0x0C]   = '\\f';
	ESCAPE_SEQUENCES[0x0D]   = '\\r';
	ESCAPE_SEQUENCES[0x1B]   = '\\e';
	ESCAPE_SEQUENCES[0x22]   = '\\"';
	ESCAPE_SEQUENCES[0x5C]   = '\\\\';
	ESCAPE_SEQUENCES[0x85]   = '\\N';
	ESCAPE_SEQUENCES[0xA0]   = '\\_';
	ESCAPE_SEQUENCES[0x2028] = '\\L';
	ESCAPE_SEQUENCES[0x2029] = '\\P';

	var DEPRECATED_BOOLEANS_SYNTAX = [
	  'y', 'Y', 'yes', 'Yes', 'YES', 'on', 'On', 'ON',
	  'n', 'N', 'no', 'No', 'NO', 'off', 'Off', 'OFF'
	];

	var DEPRECATED_BASE60_SYNTAX = /^[-+]?[0-9_]+(?::[0-9_]+)+(?:\.[0-9_]*)?$/;

	function compileStyleMap(schema, map) {
	  var result, keys, index, length, tag, style, type;

	  if (map === null) return {};

	  result = {};
	  keys = Object.keys(map);

	  for (index = 0, length = keys.length; index < length; index += 1) {
	    tag = keys[index];
	    style = String(map[tag]);

	    if (tag.slice(0, 2) === '!!') {
	      tag = 'tag:yaml.org,2002:' + tag.slice(2);
	    }
	    type = schema.compiledTypeMap['fallback'][tag];

	    if (type && _hasOwnProperty.call(type.styleAliases, style)) {
	      style = type.styleAliases[style];
	    }

	    result[tag] = style;
	  }

	  return result;
	}

	function encodeHex(character) {
	  var string, handle, length;

	  string = character.toString(16).toUpperCase();

	  if (character <= 0xFF) {
	    handle = 'x';
	    length = 2;
	  } else if (character <= 0xFFFF) {
	    handle = 'u';
	    length = 4;
	  } else if (character <= 0xFFFFFFFF) {
	    handle = 'U';
	    length = 8;
	  } else {
	    throw new YAMLException('code point within a string may not be greater than 0xFFFFFFFF');
	  }

	  return '\\' + handle + common.repeat('0', length - string.length) + string;
	}


	var QUOTING_TYPE_SINGLE = 1,
	    QUOTING_TYPE_DOUBLE = 2;

	function State(options) {
	  this.schema        = options['schema'] || DEFAULT_SCHEMA;
	  this.indent        = Math.max(1, (options['indent'] || 2));
	  this.noArrayIndent = options['noArrayIndent'] || false;
	  this.skipInvalid   = options['skipInvalid'] || false;
	  this.flowLevel     = (common.isNothing(options['flowLevel']) ? -1 : options['flowLevel']);
	  this.styleMap      = compileStyleMap(this.schema, options['styles'] || null);
	  this.sortKeys      = options['sortKeys'] || false;
	  this.lineWidth     = options['lineWidth'] || 80;
	  this.noRefs        = options['noRefs'] || false;
	  this.noCompatMode  = options['noCompatMode'] || false;
	  this.condenseFlow  = options['condenseFlow'] || false;
	  this.quotingType   = options['quotingType'] === '"' ? QUOTING_TYPE_DOUBLE : QUOTING_TYPE_SINGLE;
	  this.forceQuotes   = options['forceQuotes'] || false;
	  this.replacer      = typeof options['replacer'] === 'function' ? options['replacer'] : null;

	  this.implicitTypes = this.schema.compiledImplicit;
	  this.explicitTypes = this.schema.compiledExplicit;

	  this.tag = null;
	  this.result = '';

	  this.duplicates = [];
	  this.usedDuplicates = null;
	}

	// Indents every line in a string. Empty lines (\n only) are not indented.
	function indentString(string, spaces) {
	  var ind = common.repeat(' ', spaces),
	      position = 0,
	      next = -1,
	      result = '',
	      line,
	      length = string.length;

	  while (position < length) {
	    next = string.indexOf('\n', position);
	    if (next === -1) {
	      line = string.slice(position);
	      position = length;
	    } else {
	      line = string.slice(position, next + 1);
	      position = next + 1;
	    }

	    if (line.length && line !== '\n') result += ind;

	    result += line;
	  }

	  return result;
	}

	function generateNextLine(state, level) {
	  return '\n' + common.repeat(' ', state.indent * level);
	}

	function testImplicitResolving(state, str) {
	  var index, length, type;

	  for (index = 0, length = state.implicitTypes.length; index < length; index += 1) {
	    type = state.implicitTypes[index];

	    if (type.resolve(str)) {
	      return true;
	    }
	  }

	  return false;
	}

	// [33] s-white ::= s-space | s-tab
	function isWhitespace(c) {
	  return c === CHAR_SPACE || c === CHAR_TAB;
	}

	// Returns true if the character can be printed without escaping.
	// From YAML 1.2: "any allowed characters known to be non-printable
	// should also be escaped. [However,] This isn’t mandatory"
	// Derived from nb-char - \t - #x85 - #xA0 - #x2028 - #x2029.
	function isPrintable(c) {
	  return  (0x00020 <= c && c <= 0x00007E)
	      || ((0x000A1 <= c && c <= 0x00D7FF) && c !== 0x2028 && c !== 0x2029)
	      || ((0x0E000 <= c && c <= 0x00FFFD) && c !== CHAR_BOM)
	      ||  (0x10000 <= c && c <= 0x10FFFF);
	}

	// [34] ns-char ::= nb-char - s-white
	// [27] nb-char ::= c-printable - b-char - c-byte-order-mark
	// [26] b-char  ::= b-line-feed | b-carriage-return
	// Including s-white (for some reason, examples doesn't match specs in this aspect)
	// ns-char ::= c-printable - b-line-feed - b-carriage-return - c-byte-order-mark
	function isNsCharOrWhitespace(c) {
	  return isPrintable(c)
	    && c !== CHAR_BOM
	    // - b-char
	    && c !== CHAR_CARRIAGE_RETURN
	    && c !== CHAR_LINE_FEED;
	}

	// [127]  ns-plain-safe(c) ::= c = flow-out  ⇒ ns-plain-safe-out
	//                             c = flow-in   ⇒ ns-plain-safe-in
	//                             c = block-key ⇒ ns-plain-safe-out
	//                             c = flow-key  ⇒ ns-plain-safe-in
	// [128] ns-plain-safe-out ::= ns-char
	// [129]  ns-plain-safe-in ::= ns-char - c-flow-indicator
	// [130]  ns-plain-char(c) ::=  ( ns-plain-safe(c) - “:” - “#” )
	//                            | ( /* An ns-char preceding */ “#” )
	//                            | ( “:” /* Followed by an ns-plain-safe(c) */ )
	function isPlainSafe(c, prev, inblock) {
	  var cIsNsCharOrWhitespace = isNsCharOrWhitespace(c);
	  var cIsNsChar = cIsNsCharOrWhitespace && !isWhitespace(c);
	  return (
	    // ns-plain-safe
	    inblock ? // c = flow-in
	      cIsNsCharOrWhitespace
	      : cIsNsCharOrWhitespace
	        // - c-flow-indicator
	        && c !== CHAR_COMMA
	        && c !== CHAR_LEFT_SQUARE_BRACKET
	        && c !== CHAR_RIGHT_SQUARE_BRACKET
	        && c !== CHAR_LEFT_CURLY_BRACKET
	        && c !== CHAR_RIGHT_CURLY_BRACKET
	  )
	    // ns-plain-char
	    && c !== CHAR_SHARP // false on '#'
	    && !(prev === CHAR_COLON && !cIsNsChar) // false on ': '
	    || (isNsCharOrWhitespace(prev) && !isWhitespace(prev) && c === CHAR_SHARP) // change to true on '[^ ]#'
	    || (prev === CHAR_COLON && cIsNsChar); // change to true on ':[^ ]'
	}

	// Simplified test for values allowed as the first character in plain style.
	function isPlainSafeFirst(c) {
	  // Uses a subset of ns-char - c-indicator
	  // where ns-char = nb-char - s-white.
	  // No support of ( ( “?” | “:” | “-” ) /* Followed by an ns-plain-safe(c)) */ ) part
	  return isPrintable(c) && c !== CHAR_BOM
	    && !isWhitespace(c) // - s-white
	    // - (c-indicator ::=
	    // “-” | “?” | “:” | “,” | “[” | “]” | “{” | “}”
	    && c !== CHAR_MINUS
	    && c !== CHAR_QUESTION
	    && c !== CHAR_COLON
	    && c !== CHAR_COMMA
	    && c !== CHAR_LEFT_SQUARE_BRACKET
	    && c !== CHAR_RIGHT_SQUARE_BRACKET
	    && c !== CHAR_LEFT_CURLY_BRACKET
	    && c !== CHAR_RIGHT_CURLY_BRACKET
	    // | “#” | “&” | “*” | “!” | “|” | “=” | “>” | “'” | “"”
	    && c !== CHAR_SHARP
	    && c !== CHAR_AMPERSAND
	    && c !== CHAR_ASTERISK
	    && c !== CHAR_EXCLAMATION
	    && c !== CHAR_VERTICAL_LINE
	    && c !== CHAR_EQUALS
	    && c !== CHAR_GREATER_THAN
	    && c !== CHAR_SINGLE_QUOTE
	    && c !== CHAR_DOUBLE_QUOTE
	    // | “%” | “@” | “`”)
	    && c !== CHAR_PERCENT
	    && c !== CHAR_COMMERCIAL_AT
	    && c !== CHAR_GRAVE_ACCENT;
	}

	// Simplified test for values allowed as the last character in plain style.
	function isPlainSafeLast(c) {
	  // just not whitespace or colon, it will be checked to be plain character later
	  return !isWhitespace(c) && c !== CHAR_COLON;
	}

	// Same as 'string'.codePointAt(pos), but works in older browsers.
	function codePointAt(string, pos) {
	  var first = string.charCodeAt(pos), second;
	  if (first >= 0xD800 && first <= 0xDBFF && pos + 1 < string.length) {
	    second = string.charCodeAt(pos + 1);
	    if (second >= 0xDC00 && second <= 0xDFFF) {
	      // https://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
	      return (first - 0xD800) * 0x400 + second - 0xDC00 + 0x10000;
	    }
	  }
	  return first;
	}

	// Determines whether block indentation indicator is required.
	function needIndentIndicator(string) {
	  var leadingSpaceRe = /^\n* /;
	  return leadingSpaceRe.test(string);
	}

	var STYLE_PLAIN   = 1,
	    STYLE_SINGLE  = 2,
	    STYLE_LITERAL = 3,
	    STYLE_FOLDED  = 4,
	    STYLE_DOUBLE  = 5;

	// Determines which scalar styles are possible and returns the preferred style.
	// lineWidth = -1 => no limit.
	// Pre-conditions: str.length > 0.
	// Post-conditions:
	//    STYLE_PLAIN or STYLE_SINGLE => no \n are in the string.
	//    STYLE_LITERAL => no lines are suitable for folding (or lineWidth is -1).
	//    STYLE_FOLDED => a line > lineWidth and can be folded (and lineWidth != -1).
	function chooseScalarStyle(string, singleLineOnly, indentPerLevel, lineWidth,
	  testAmbiguousType, quotingType, forceQuotes, inblock) {

	  var i;
	  var char = 0;
	  var prevChar = null;
	  var hasLineBreak = false;
	  var hasFoldableLine = false; // only checked if shouldTrackWidth
	  var shouldTrackWidth = lineWidth !== -1;
	  var previousLineBreak = -1; // count the first line correctly
	  var plain = isPlainSafeFirst(codePointAt(string, 0))
	          && isPlainSafeLast(codePointAt(string, string.length - 1));

	  if (singleLineOnly || forceQuotes) {
	    // Case: no block styles.
	    // Check for disallowed characters to rule out plain and single.
	    for (i = 0; i < string.length; char >= 0x10000 ? i += 2 : i++) {
	      char = codePointAt(string, i);
	      if (!isPrintable(char)) {
	        return STYLE_DOUBLE;
	      }
	      plain = plain && isPlainSafe(char, prevChar, inblock);
	      prevChar = char;
	    }
	  } else {
	    // Case: block styles permitted.
	    for (i = 0; i < string.length; char >= 0x10000 ? i += 2 : i++) {
	      char = codePointAt(string, i);
	      if (char === CHAR_LINE_FEED) {
	        hasLineBreak = true;
	        // Check if any line can be folded.
	        if (shouldTrackWidth) {
	          hasFoldableLine = hasFoldableLine ||
	            // Foldable line = too long, and not more-indented.
	            (i - previousLineBreak - 1 > lineWidth &&
	             string[previousLineBreak + 1] !== ' ');
	          previousLineBreak = i;
	        }
	      } else if (!isPrintable(char)) {
	        return STYLE_DOUBLE;
	      }
	      plain = plain && isPlainSafe(char, prevChar, inblock);
	      prevChar = char;
	    }
	    // in case the end is missing a \n
	    hasFoldableLine = hasFoldableLine || (shouldTrackWidth &&
	      (i - previousLineBreak - 1 > lineWidth &&
	       string[previousLineBreak + 1] !== ' '));
	  }
	  // Although every style can represent \n without escaping, prefer block styles
	  // for multiline, since they're more readable and they don't add empty lines.
	  // Also prefer folding a super-long line.
	  if (!hasLineBreak && !hasFoldableLine) {
	    // Strings interpretable as another type have to be quoted;
	    // e.g. the string 'true' vs. the boolean true.
	    if (plain && !forceQuotes && !testAmbiguousType(string)) {
	      return STYLE_PLAIN;
	    }
	    return quotingType === QUOTING_TYPE_DOUBLE ? STYLE_DOUBLE : STYLE_SINGLE;
	  }
	  // Edge case: block indentation indicator can only have one digit.
	  if (indentPerLevel > 9 && needIndentIndicator(string)) {
	    return STYLE_DOUBLE;
	  }
	  // At this point we know block styles are valid.
	  // Prefer literal style unless we want to fold.
	  if (!forceQuotes) {
	    return hasFoldableLine ? STYLE_FOLDED : STYLE_LITERAL;
	  }
	  return quotingType === QUOTING_TYPE_DOUBLE ? STYLE_DOUBLE : STYLE_SINGLE;
	}

	// Note: line breaking/folding is implemented for only the folded style.
	// NB. We drop the last trailing newline (if any) of a returned block scalar
	//  since the dumper adds its own newline. This always works:
	//    • No ending newline => unaffected; already using strip "-" chomping.
	//    • Ending newline    => removed then restored.
	//  Importantly, this keeps the "+" chomp indicator from gaining an extra line.
	function writeScalar(state, string, level, iskey, inblock) {
	  state.dump = (function () {
	    if (string.length === 0) {
	      return state.quotingType === QUOTING_TYPE_DOUBLE ? '""' : "''";
	    }
	    if (!state.noCompatMode) {
	      if (DEPRECATED_BOOLEANS_SYNTAX.indexOf(string) !== -1 || DEPRECATED_BASE60_SYNTAX.test(string)) {
	        return state.quotingType === QUOTING_TYPE_DOUBLE ? ('"' + string + '"') : ("'" + string + "'");
	      }
	    }

	    var indent = state.indent * Math.max(1, level); // no 0-indent scalars
	    // As indentation gets deeper, let the width decrease monotonically
	    // to the lower bound min(state.lineWidth, 40).
	    // Note that this implies
	    //  state.lineWidth ≤ 40 + state.indent: width is fixed at the lower bound.
	    //  state.lineWidth > 40 + state.indent: width decreases until the lower bound.
	    // This behaves better than a constant minimum width which disallows narrower options,
	    // or an indent threshold which causes the width to suddenly increase.
	    var lineWidth = state.lineWidth === -1
	      ? -1 : Math.max(Math.min(state.lineWidth, 40), state.lineWidth - indent);

	    // Without knowing if keys are implicit/explicit, assume implicit for safety.
	    var singleLineOnly = iskey
	      // No block styles in flow mode.
	      || (state.flowLevel > -1 && level >= state.flowLevel);
	    function testAmbiguity(string) {
	      return testImplicitResolving(state, string);
	    }

	    switch (chooseScalarStyle(string, singleLineOnly, state.indent, lineWidth,
	      testAmbiguity, state.quotingType, state.forceQuotes && !iskey, inblock)) {

	      case STYLE_PLAIN:
	        return string;
	      case STYLE_SINGLE:
	        return "'" + string.replace(/'/g, "''") + "'";
	      case STYLE_LITERAL:
	        return '|' + blockHeader(string, state.indent)
	          + dropEndingNewline(indentString(string, indent));
	      case STYLE_FOLDED:
	        return '>' + blockHeader(string, state.indent)
	          + dropEndingNewline(indentString(foldString(string, lineWidth), indent));
	      case STYLE_DOUBLE:
	        return '"' + escapeString(string) + '"';
	      default:
	        throw new YAMLException('impossible error: invalid scalar style');
	    }
	  }());
	}

	// Pre-conditions: string is valid for a block scalar, 1 <= indentPerLevel <= 9.
	function blockHeader(string, indentPerLevel) {
	  var indentIndicator = needIndentIndicator(string) ? String(indentPerLevel) : '';

	  // note the special case: the string '\n' counts as a "trailing" empty line.
	  var clip =          string[string.length - 1] === '\n';
	  var keep = clip && (string[string.length - 2] === '\n' || string === '\n');
	  var chomp = keep ? '+' : (clip ? '' : '-');

	  return indentIndicator + chomp + '\n';
	}

	// (See the note for writeScalar.)
	function dropEndingNewline(string) {
	  return string[string.length - 1] === '\n' ? string.slice(0, -1) : string;
	}

	// Note: a long line without a suitable break point will exceed the width limit.
	// Pre-conditions: every char in str isPrintable, str.length > 0, width > 0.
	function foldString(string, width) {
	  // In folded style, $k$ consecutive newlines output as $k+1$ newlines—
	  // unless they're before or after a more-indented line, or at the very
	  // beginning or end, in which case $k$ maps to $k$.
	  // Therefore, parse each chunk as newline(s) followed by a content line.
	  var lineRe = /(\n+)([^\n]*)/g;

	  // first line (possibly an empty line)
	  var result = (function () {
	    var nextLF = string.indexOf('\n');
	    nextLF = nextLF !== -1 ? nextLF : string.length;
	    lineRe.lastIndex = nextLF;
	    return foldLine(string.slice(0, nextLF), width);
	  }());
	  // If we haven't reached the first content line yet, don't add an extra \n.
	  var prevMoreIndented = string[0] === '\n' || string[0] === ' ';
	  var moreIndented;

	  // rest of the lines
	  var match;
	  while ((match = lineRe.exec(string))) {
	    var prefix = match[1], line = match[2];
	    moreIndented = (line[0] === ' ');
	    result += prefix
	      + (!prevMoreIndented && !moreIndented && line !== ''
	        ? '\n' : '')
	      + foldLine(line, width);
	    prevMoreIndented = moreIndented;
	  }

	  return result;
	}

	// Greedy line breaking.
	// Picks the longest line under the limit each time,
	// otherwise settles for the shortest line over the limit.
	// NB. More-indented lines *cannot* be folded, as that would add an extra \n.
	function foldLine(line, width) {
	  if (line === '' || line[0] === ' ') return line;

	  // Since a more-indented line adds a \n, breaks can't be followed by a space.
	  var breakRe = / [^ ]/g; // note: the match index will always be <= length-2.
	  var match;
	  // start is an inclusive index. end, curr, and next are exclusive.
	  var start = 0, end, curr = 0, next = 0;
	  var result = '';

	  // Invariants: 0 <= start <= length-1.
	  //   0 <= curr <= next <= max(0, length-2). curr - start <= width.
	  // Inside the loop:
	  //   A match implies length >= 2, so curr and next are <= length-2.
	  while ((match = breakRe.exec(line))) {
	    next = match.index;
	    // maintain invariant: curr - start <= width
	    if (next - start > width) {
	      end = (curr > start) ? curr : next; // derive end <= length-2
	      result += '\n' + line.slice(start, end);
	      // skip the space that was output as \n
	      start = end + 1;                    // derive start <= length-1
	    }
	    curr = next;
	  }

	  // By the invariants, start <= length-1, so there is something left over.
	  // It is either the whole string or a part starting from non-whitespace.
	  result += '\n';
	  // Insert a break if the remainder is too long and there is a break available.
	  if (line.length - start > width && curr > start) {
	    result += line.slice(start, curr) + '\n' + line.slice(curr + 1);
	  } else {
	    result += line.slice(start);
	  }

	  return result.slice(1); // drop extra \n joiner
	}

	// Escapes a double-quoted string.
	function escapeString(string) {
	  var result = '';
	  var char = 0;
	  var escapeSeq;

	  for (var i = 0; i < string.length; char >= 0x10000 ? i += 2 : i++) {
	    char = codePointAt(string, i);
	    escapeSeq = ESCAPE_SEQUENCES[char];

	    if (!escapeSeq && isPrintable(char)) {
	      result += string[i];
	      if (char >= 0x10000) result += string[i + 1];
	    } else {
	      result += escapeSeq || encodeHex(char);
	    }
	  }

	  return result;
	}

	function writeFlowSequence(state, level, object) {
	  var _result = '',
	      _tag    = state.tag,
	      index,
	      length,
	      value;

	  for (index = 0, length = object.length; index < length; index += 1) {
	    value = object[index];

	    if (state.replacer) {
	      value = state.replacer.call(object, String(index), value);
	    }

	    // Write only valid elements, put null instead of invalid elements.
	    if (writeNode(state, level, value, false, false) ||
	        (typeof value === 'undefined' &&
	         writeNode(state, level, null, false, false))) {

	      if (_result !== '') _result += ',' + (!state.condenseFlow ? ' ' : '');
	      _result += state.dump;
	    }
	  }

	  state.tag = _tag;
	  state.dump = '[' + _result + ']';
	}

	function writeBlockSequence(state, level, object, compact) {
	  var _result = '',
	      _tag    = state.tag,
	      index,
	      length,
	      value;

	  for (index = 0, length = object.length; index < length; index += 1) {
	    value = object[index];

	    if (state.replacer) {
	      value = state.replacer.call(object, String(index), value);
	    }

	    // Write only valid elements, put null instead of invalid elements.
	    if (writeNode(state, level + 1, value, true, true, false, true) ||
	        (typeof value === 'undefined' &&
	         writeNode(state, level + 1, null, true, true, false, true))) {

	      if (!compact || _result !== '') {
	        _result += generateNextLine(state, level);
	      }

	      if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) {
	        _result += '-';
	      } else {
	        _result += '- ';
	      }

	      _result += state.dump;
	    }
	  }

	  state.tag = _tag;
	  state.dump = _result || '[]'; // Empty sequence if no valid values.
	}

	function writeFlowMapping(state, level, object) {
	  var _result       = '',
	      _tag          = state.tag,
	      objectKeyList = Object.keys(object),
	      index,
	      length,
	      objectKey,
	      objectValue,
	      pairBuffer;

	  for (index = 0, length = objectKeyList.length; index < length; index += 1) {

	    pairBuffer = '';
	    if (_result !== '') pairBuffer += ', ';

	    if (state.condenseFlow) pairBuffer += '"';

	    objectKey = objectKeyList[index];
	    objectValue = object[objectKey];

	    if (state.replacer) {
	      objectValue = state.replacer.call(object, objectKey, objectValue);
	    }

	    if (!writeNode(state, level, objectKey, false, false)) {
	      continue; // Skip this pair because of invalid key;
	    }

	    if (state.dump.length > 1024) pairBuffer += '? ';

	    pairBuffer += state.dump + (state.condenseFlow ? '"' : '') + ':' + (state.condenseFlow ? '' : ' ');

	    if (!writeNode(state, level, objectValue, false, false)) {
	      continue; // Skip this pair because of invalid value.
	    }

	    pairBuffer += state.dump;

	    // Both key and value are valid.
	    _result += pairBuffer;
	  }

	  state.tag = _tag;
	  state.dump = '{' + _result + '}';
	}

	function writeBlockMapping(state, level, object, compact) {
	  var _result       = '',
	      _tag          = state.tag,
	      objectKeyList = Object.keys(object),
	      index,
	      length,
	      objectKey,
	      objectValue,
	      explicitPair,
	      pairBuffer;

	  // Allow sorting keys so that the output file is deterministic
	  if (state.sortKeys === true) {
	    // Default sorting
	    objectKeyList.sort();
	  } else if (typeof state.sortKeys === 'function') {
	    // Custom sort function
	    objectKeyList.sort(state.sortKeys);
	  } else if (state.sortKeys) {
	    // Something is wrong
	    throw new YAMLException('sortKeys must be a boolean or a function');
	  }

	  for (index = 0, length = objectKeyList.length; index < length; index += 1) {
	    pairBuffer = '';

	    if (!compact || _result !== '') {
	      pairBuffer += generateNextLine(state, level);
	    }

	    objectKey = objectKeyList[index];
	    objectValue = object[objectKey];

	    if (state.replacer) {
	      objectValue = state.replacer.call(object, objectKey, objectValue);
	    }

	    if (!writeNode(state, level + 1, objectKey, true, true, true)) {
	      continue; // Skip this pair because of invalid key.
	    }

	    explicitPair = (state.tag !== null && state.tag !== '?') ||
	                   (state.dump && state.dump.length > 1024);

	    if (explicitPair) {
	      if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) {
	        pairBuffer += '?';
	      } else {
	        pairBuffer += '? ';
	      }
	    }

	    pairBuffer += state.dump;

	    if (explicitPair) {
	      pairBuffer += generateNextLine(state, level);
	    }

	    if (!writeNode(state, level + 1, objectValue, true, explicitPair)) {
	      continue; // Skip this pair because of invalid value.
	    }

	    if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) {
	      pairBuffer += ':';
	    } else {
	      pairBuffer += ': ';
	    }

	    pairBuffer += state.dump;

	    // Both key and value are valid.
	    _result += pairBuffer;
	  }

	  state.tag = _tag;
	  state.dump = _result || '{}'; // Empty mapping if no valid pairs.
	}

	function detectType(state, object, explicit) {
	  var _result, typeList, index, length, type, style;

	  typeList = explicit ? state.explicitTypes : state.implicitTypes;

	  for (index = 0, length = typeList.length; index < length; index += 1) {
	    type = typeList[index];

	    if ((type.instanceOf  || type.predicate) &&
	        (!type.instanceOf || ((typeof object === 'object') && (object instanceof type.instanceOf))) &&
	        (!type.predicate  || type.predicate(object))) {

	      if (explicit) {
	        if (type.multi && type.representName) {
	          state.tag = type.representName(object);
	        } else {
	          state.tag = type.tag;
	        }
	      } else {
	        state.tag = '?';
	      }

	      if (type.represent) {
	        style = state.styleMap[type.tag] || type.defaultStyle;

	        if (_toString.call(type.represent) === '[object Function]') {
	          _result = type.represent(object, style);
	        } else if (_hasOwnProperty.call(type.represent, style)) {
	          _result = type.represent[style](object, style);
	        } else {
	          throw new YAMLException('!<' + type.tag + '> tag resolver accepts not "' + style + '" style');
	        }

	        state.dump = _result;
	      }

	      return true;
	    }
	  }

	  return false;
	}

	// Serializes `object` and writes it to global `result`.
	// Returns true on success, or false on invalid object.
	//
	function writeNode(state, level, object, block, compact, iskey, isblockseq) {
	  state.tag = null;
	  state.dump = object;

	  if (!detectType(state, object, false)) {
	    detectType(state, object, true);
	  }

	  var type = _toString.call(state.dump);
	  var inblock = block;
	  var tagStr;

	  if (block) {
	    block = (state.flowLevel < 0 || state.flowLevel > level);
	  }

	  var objectOrArray = type === '[object Object]' || type === '[object Array]',
	      duplicateIndex,
	      duplicate;

	  if (objectOrArray) {
	    duplicateIndex = state.duplicates.indexOf(object);
	    duplicate = duplicateIndex !== -1;
	  }

	  if ((state.tag !== null && state.tag !== '?') || duplicate || (state.indent !== 2 && level > 0)) {
	    compact = false;
	  }

	  if (duplicate && state.usedDuplicates[duplicateIndex]) {
	    state.dump = '*ref_' + duplicateIndex;
	  } else {
	    if (objectOrArray && duplicate && !state.usedDuplicates[duplicateIndex]) {
	      state.usedDuplicates[duplicateIndex] = true;
	    }
	    if (type === '[object Object]') {
	      if (block && (Object.keys(state.dump).length !== 0)) {
	        writeBlockMapping(state, level, state.dump, compact);
	        if (duplicate) {
	          state.dump = '&ref_' + duplicateIndex + state.dump;
	        }
	      } else {
	        writeFlowMapping(state, level, state.dump);
	        if (duplicate) {
	          state.dump = '&ref_' + duplicateIndex + ' ' + state.dump;
	        }
	      }
	    } else if (type === '[object Array]') {
	      if (block && (state.dump.length !== 0)) {
	        if (state.noArrayIndent && !isblockseq && level > 0) {
	          writeBlockSequence(state, level - 1, state.dump, compact);
	        } else {
	          writeBlockSequence(state, level, state.dump, compact);
	        }
	        if (duplicate) {
	          state.dump = '&ref_' + duplicateIndex + state.dump;
	        }
	      } else {
	        writeFlowSequence(state, level, state.dump);
	        if (duplicate) {
	          state.dump = '&ref_' + duplicateIndex + ' ' + state.dump;
	        }
	      }
	    } else if (type === '[object String]') {
	      if (state.tag !== '?') {
	        writeScalar(state, state.dump, level, iskey, inblock);
	      }
	    } else if (type === '[object Undefined]') {
	      return false;
	    } else {
	      if (state.skipInvalid) return false;
	      throw new YAMLException('unacceptable kind of an object to dump ' + type);
	    }

	    if (state.tag !== null && state.tag !== '?') {
	      // Need to encode all characters except those allowed by the spec:
	      //
	      // [35] ns-dec-digit    ::=  [#x30-#x39] /* 0-9 */
	      // [36] ns-hex-digit    ::=  ns-dec-digit
	      //                         | [#x41-#x46] /* A-F */ | [#x61-#x66] /* a-f */
	      // [37] ns-ascii-letter ::=  [#x41-#x5A] /* A-Z */ | [#x61-#x7A] /* a-z */
	      // [38] ns-word-char    ::=  ns-dec-digit | ns-ascii-letter | “-”
	      // [39] ns-uri-char     ::=  “%” ns-hex-digit ns-hex-digit | ns-word-char | “#”
	      //                         | “;” | “/” | “?” | “:” | “@” | “&” | “=” | “+” | “$” | “,”
	      //                         | “_” | “.” | “!” | “~” | “*” | “'” | “(” | “)” | “[” | “]”
	      //
	      // Also need to encode '!' because it has special meaning (end of tag prefix).
	      //
	      tagStr = encodeURI(
	        state.tag[0] === '!' ? state.tag.slice(1) : state.tag
	      ).replace(/!/g, '%21');

	      if (state.tag[0] === '!') {
	        tagStr = '!' + tagStr;
	      } else if (tagStr.slice(0, 18) === 'tag:yaml.org,2002:') {
	        tagStr = '!!' + tagStr.slice(18);
	      } else {
	        tagStr = '!<' + tagStr + '>';
	      }

	      state.dump = tagStr + ' ' + state.dump;
	    }
	  }

	  return true;
	}

	function getDuplicateReferences(object, state) {
	  var objects = [],
	      duplicatesIndexes = [],
	      index,
	      length;

	  inspectNode(object, objects, duplicatesIndexes);

	  for (index = 0, length = duplicatesIndexes.length; index < length; index += 1) {
	    state.duplicates.push(objects[duplicatesIndexes[index]]);
	  }
	  state.usedDuplicates = new Array(length);
	}

	function inspectNode(object, objects, duplicatesIndexes) {
	  var objectKeyList,
	      index,
	      length;

	  if (object !== null && typeof object === 'object') {
	    index = objects.indexOf(object);
	    if (index !== -1) {
	      if (duplicatesIndexes.indexOf(index) === -1) {
	        duplicatesIndexes.push(index);
	      }
	    } else {
	      objects.push(object);

	      if (Array.isArray(object)) {
	        for (index = 0, length = object.length; index < length; index += 1) {
	          inspectNode(object[index], objects, duplicatesIndexes);
	        }
	      } else {
	        objectKeyList = Object.keys(object);

	        for (index = 0, length = objectKeyList.length; index < length; index += 1) {
	          inspectNode(object[objectKeyList[index]], objects, duplicatesIndexes);
	        }
	      }
	    }
	  }
	}

	function dump(input, options) {
	  options = options || {};

	  var state = new State(options);

	  if (!state.noRefs) getDuplicateReferences(input, state);

	  var value = input;

	  if (state.replacer) {
	    value = state.replacer.call({ '': value }, '', value);
	  }

	  if (writeNode(state, 0, value, true, true)) return state.dump + '\n';

	  return '';
	}

	dumper.dump = dump;
	return dumper;
}

var hasRequiredJsYaml;

function requireJsYaml () {
	if (hasRequiredJsYaml) return jsYaml;
	hasRequiredJsYaml = 1;


	var loader = requireLoader();
	var dumper = requireDumper();


	function renamed(from, to) {
	  return function () {
	    throw new Error('Function yaml.' + from + ' is removed in js-yaml 4. ' +
	      'Use yaml.' + to + ' instead, which is now safe by default.');
	  };
	}


	jsYaml.Type                = requireType();
	jsYaml.Schema              = requireSchema();
	jsYaml.FAILSAFE_SCHEMA     = requireFailsafe();
	jsYaml.JSON_SCHEMA         = requireJson();
	jsYaml.CORE_SCHEMA         = requireCore();
	jsYaml.DEFAULT_SCHEMA      = require_default();
	jsYaml.load                = loader.load;
	jsYaml.loadAll             = loader.loadAll;
	jsYaml.dump                = dumper.dump;
	jsYaml.YAMLException       = requireException();

	// Re-export all types in case user wants to create custom schema
	jsYaml.types = {
	  binary:    requireBinary(),
	  float:     requireFloat(),
	  map:       requireMap(),
	  null:      require_null(),
	  pairs:     requirePairs(),
	  set:       requireSet(),
	  timestamp: requireTimestamp(),
	  bool:      requireBool(),
	  int:       requireInt(),
	  merge:     requireMerge(),
	  omap:      requireOmap(),
	  seq:       requireSeq(),
	  str:       requireStr()
	};

	// Removed functions from JS-YAML 3.0.x
	jsYaml.safeLoad            = renamed('safeLoad', 'load');
	jsYaml.safeLoadAll         = renamed('safeLoadAll', 'loadAll');
	jsYaml.safeDump            = renamed('safeDump', 'dump');
	return jsYaml;
}

var hasRequiredConfiguration;

function requireConfiguration () {
	if (hasRequiredConfiguration) return configuration;
	hasRequiredConfiguration = 1;
	var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
	    if (k2 === undefined) k2 = k;
	    var desc = Object.getOwnPropertyDescriptor(m, k);
	    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
	      desc = { enumerable: true, get: function() { return m[k]; } };
	    }
	    Object.defineProperty(o, k2, desc);
	}) : (function(o, m, k, k2) {
	    if (k2 === undefined) k2 = k;
	    o[k2] = m[k];
	}));
	var __setModuleDefault = (commonjsGlobal && commonjsGlobal.__setModuleDefault) || (Object.create ? (function(o, v) {
	    Object.defineProperty(o, "default", { enumerable: true, value: v });
	}) : function(o, v) {
	    o["default"] = v;
	});
	var __importStar = (commonjsGlobal && commonjsGlobal.__importStar) || function (mod) {
	    if (mod && mod.__esModule) return mod;
	    var result = {};
	    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
	    __setModuleDefault(result, mod);
	    return result;
	};
	var __awaiter = (commonjsGlobal && commonjsGlobal.__awaiter) || function (thisArg, _arguments, P, generator) {
	    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
	    return new (P || (P = Promise))(function (resolve, reject) {
	        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
	        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
	        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
	        step((generator = generator.apply(thisArg, _arguments || [])).next());
	    });
	};
	var __generator = (commonjsGlobal && commonjsGlobal.__generator) || function (thisArg, body) {
	    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
	    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
	    function verb(n) { return function (v) { return step([n, v]); }; }
	    function step(op) {
	        if (f) throw new TypeError("Generator is already executing.");
	        while (g && (g = 0, op[0] && (_ = 0)), _) try {
	            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
	            if (y = 0, t) op = [op[0] & 2, t.value];
	            switch (op[0]) {
	                case 0: case 1: t = op; break;
	                case 4: _.label++; return { value: op[1], done: false };
	                case 5: _.label++; y = op[1]; op = [0]; continue;
	                case 7: op = _.ops.pop(); _.trys.pop(); continue;
	                default:
	                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
	                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
	                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
	                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
	                    if (t[2]) _.ops.pop();
	                    _.trys.pop(); continue;
	            }
	            op = body.call(thisArg, _);
	        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
	        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
	    }
	};
	var __importDefault = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
	    return (mod && mod.__esModule) ? mod : { "default": mod };
	};
	Object.defineProperty(configuration, "__esModule", { value: true });
	configuration.Configuration = void 0;
	var axios_1 = __importDefault(requireAxios());
	var os = __importStar(require$$0$1);
	var path = __importStar(require$$2);
	var yaml = __importStar(requireJsYaml());
	var fs = __importStar(require$$6);
	var form_data_1 = __importDefault(requireForm_data());
	var Configuration = /** @class */ (function () {
	    function Configuration(param) {
	        if (!param) {
	            param = this.getParams();
	        }
	        this.accessToken = param.accessToken;
	        this.basePath = param.baseurl;
	        this.tokenUrl = param.tokenUrl;
	        this.clientId = param.clientId;
	        this.clientSecret = param.clientSecret;
	        var url = "".concat(this.tokenUrl);
	        var formData = new form_data_1.default();
	        formData.append('grant_type', 'client_credentials');
	        formData.append('client_id', this.clientId);
	        formData.append('client_secret', this.clientSecret);
	        if (!this.accessToken) {
	            this.accessToken = this.getAccessToken(url, formData);
	        }
	    }
	    Configuration.prototype.getHomeParams = function () {
	        var config = {};
	        try {
	            var homeDir = os.homedir();
	            var configPath = path.join(homeDir, '.sailpoint', 'config.yaml');
	            var doc = yaml.load(fs.readFileSync(configPath, 'utf8'));
	            if (doc.authtype && doc.authtype.toLowerCase() === 'pat') {
	                config.baseurl = doc.environments[doc.activeenvironment].baseurl;
	                config.clientId = doc.environments[doc.activeenvironment].pat.clientid;
	                config.clientSecret = doc.environments[doc.activeenvironment].pat.clientsecret;
	                config.tokenUrl = config.baseurl + '/oauth/token';
	            }
	        }
	        catch (error) {
	            console.log('unable to find config file in home directory');
	        }
	        return config;
	    };
	    Configuration.prototype.getLocalParams = function () {
	        var config = {};
	        try {
	            var configPath = './config.json';
	            var jsonString = fs.readFileSync(configPath, 'utf-8');
	            var jsonData = JSON.parse(jsonString);
	            config.baseurl = jsonData.BaseURL;
	            config.clientId = jsonData.ClientId;
	            config.clientSecret = jsonData.ClientSecret;
	            config.tokenUrl = config.baseurl + '/oauth/token';
	        }
	        catch (error) {
	            console.log('unable to find config file in local directory');
	        }
	        return config;
	    };
	    Configuration.prototype.getEnvParams = function () {
	        var config = {};
	        config.baseurl = process.env["SAIL_BASE_URL"] ? process.env["SAIL_BASE_URL"] : "";
	        config.clientId = process.env["SAIL_CLIENT_ID"] ? process.env["SAIL_CLIENT_ID"] : "";
	        config.clientSecret = process.env["SAIL_CLIENT_SECRET"] ? process.env["SAIL_CLIENT_SECRET"] : "";
	        config.tokenUrl = config.baseurl + '/oauth/token';
	        return config;
	    };
	    Configuration.prototype.getParams = function () {
	        var envConfig = this.getEnvParams();
	        if (envConfig.baseurl) {
	            return envConfig;
	        }
	        var localConfig = this.getLocalParams();
	        if (localConfig.baseurl) {
	            return localConfig;
	        }
	        var homeConfig = this.getHomeParams();
	        if (homeConfig.baseurl) {
	            console.log("Configuration file found in home directory, this approach of loading configuration will be deprecated in future releases, please upgrade the CLI and use the new 'sail sdk init config' command to create a local configuration file");
	            return homeConfig;
	        }
	        return {};
	    };
	    Configuration.prototype.getAccessToken = function (url, formData) {
	        return __awaiter(this, void 0, void 0, function () {
	            var _a, data, status_1, error_1;
	            return __generator(this, function (_b) {
	                switch (_b.label) {
	                    case 0:
	                        _b.trys.push([0, 2, , 3]);
	                        return [4 /*yield*/, axios_1.default.post(url, formData)];
	                    case 1:
	                        _a = _b.sent(), data = _a.data, status_1 = _a.status;
	                        if (status_1 === 200) {
	                            return [2 /*return*/, data.access_token];
	                        }
	                        else {
	                            throw new Error("Unauthorized");
	                        }
	                    case 2:
	                        error_1 = _b.sent();
	                        console.error("Unable to fetch access token.  Aborting.");
	                        throw new Error(error_1);
	                    case 3: return [2 /*return*/];
	                }
	            });
	        });
	    };
	    /**
	     * Check if the given MIME is a JSON MIME.
	     * JSON MIME examples:
	     *   application/json
	     *   application/json; charset=UTF8
	     *   APPLICATION/JSON
	     *   application/vnd.company+json
	     * @param mime - MIME (Multipurpose Internet Mail Extensions)
	     * @return True if the given MIME is JSON, false otherwise.
	     */
	    Configuration.prototype.isJsonMime = function (mime) {
	        var jsonMime = new RegExp('^(application\/json|[^;/ \t]+\/[^;/ \t]+[+]json)[ \t]*(;.*)?$', 'i');
	        return mime !== null && (jsonMime.test(mime) || mime.toLowerCase() === 'application/json-patch+json');
	    };
	    return Configuration;
	}());
	configuration.Configuration = Configuration;
	
	return configuration;
}

var paginator = {};

var hasRequiredPaginator;

function requirePaginator () {
	if (hasRequiredPaginator) return paginator;
	hasRequiredPaginator = 1;
	var __awaiter = (commonjsGlobal && commonjsGlobal.__awaiter) || function (thisArg, _arguments, P, generator) {
	    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
	    return new (P || (P = Promise))(function (resolve, reject) {
	        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
	        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
	        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
	        step((generator = generator.apply(thisArg, _arguments || [])).next());
	    });
	};
	var __generator = (commonjsGlobal && commonjsGlobal.__generator) || function (thisArg, body) {
	    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
	    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
	    function verb(n) { return function (v) { return step([n, v]); }; }
	    function step(op) {
	        if (f) throw new TypeError("Generator is already executing.");
	        while (g && (g = 0, op[0] && (_ = 0)), _) try {
	            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
	            if (y = 0, t) op = [op[0] & 2, t.value];
	            switch (op[0]) {
	                case 0: case 1: t = op; break;
	                case 4: _.label++; return { value: op[1], done: false };
	                case 5: _.label++; y = op[1]; op = [0]; continue;
	                case 7: op = _.ops.pop(); _.trys.pop(); continue;
	                default:
	                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
	                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
	                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
	                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
	                    if (t[2]) _.ops.pop();
	                    _.trys.pop(); continue;
	            }
	            op = body.call(thisArg, _);
	        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
	        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
	    }
	};
	Object.defineProperty(paginator, "__esModule", { value: true });
	paginator.Paginator = void 0;
	var Paginator = /** @class */ (function () {
	    function Paginator() {
	    }
	    Paginator.paginate = function (thisArg, callbackFn, args, increment) {
	        return __awaiter(this, void 0, void 0, function () {
	            var params, maxLimit, modified, results;
	            return __generator(this, function (_a) {
	                switch (_a.label) {
	                    case 0:
	                        params = args ? args : { limit: 0, offset: 0 };
	                        maxLimit = params && params.limit ? params.limit : 0;
	                        if (!params.offset) {
	                            params.offset = 0;
	                        }
	                        if (!increment) {
	                            increment = 250;
	                        }
	                        params.limit = increment;
	                        modified = [];
	                        _a.label = 1;
	                    case 1:
	                        console.log("Paginating call, offset = ".concat(params.offset));
	                        return [4 /*yield*/, callbackFn.call(thisArg, params)];
	                    case 2:
	                        results = _a.sent();
	                        modified.push.apply(modified, results.data);
	                        if (results.data.length < increment ||
	                            (modified.length >= maxLimit && maxLimit > 0)) {
	                            results.data = modified;
	                            return [2 /*return*/, results];
	                        }
	                        params.offset += increment;
	                        return [3 /*break*/, 1];
	                    case 3: return [2 /*return*/];
	                }
	            });
	        });
	    };
	    Paginator.paginateSearchApi = function (searchAPI, search, increment, limit) {
	        return __awaiter(this, void 0, void 0, function () {
	            var searchParams, offset, maxLimit, modified, results, result;
	            return __generator(this, function (_a) {
	                switch (_a.label) {
	                    case 0:
	                        increment = increment ? increment : 250;
	                        searchParams = {
	                            search: search,
	                            limit: increment,
	                        };
	                        offset = 0;
	                        maxLimit = limit ? limit : 0;
	                        modified = [];
	                        if (!search.sort || search.sort.length != 1) {
	                            throw "search must include exactly one sort parameter to paginate properly";
	                        }
	                        _a.label = 1;
	                    case 1:
	                        console.log("Paginating call, offset = ".concat(offset));
	                        return [4 /*yield*/, searchAPI.searchPost(searchParams)];
	                    case 2:
	                        results = _a.sent();
	                        modified.push.apply(modified, results.data);
	                        if (results.data.length < increment ||
	                            (modified.length >= maxLimit && maxLimit > 0)) {
	                            results.data = modified;
	                            return [2 /*return*/, results];
	                        }
	                        else {
	                            result = results.data[results.data.length - 1];
	                            if (searchParams.search.sort) {
	                                searchParams.search.searchAfter = [
	                                    result[searchParams.search.sort[0].replace("-", "")],
	                                ];
	                            }
	                            else {
	                                throw "search unexpectedly did not return a result we can search after!";
	                            }
	                        }
	                        offset += increment;
	                        return [3 /*break*/, 1];
	                    case 3: return [2 /*return*/];
	                }
	            });
	        });
	    };
	    return Paginator;
	}());
	paginator.Paginator = Paginator;
	
	return paginator;
}

var hasRequiredDist;

function requireDist () {
	if (hasRequiredDist) return dist;
	hasRequiredDist = 1;
	(function (exports) {
		/* tslint:disable */
		/* eslint-disable */
		/**
		 * IdentityNow V3 API
		 * Use these APIs to interact with the IdentityNow platform to achieve repeatable, automated processes with greater scalability. We encourage you to join the SailPoint Developer Community forum at https://developer.sailpoint.com/discuss to connect with other developers using our APIs.
		 *
		 * The version of the OpenAPI document: 3.0.0
		 *
		 *
		 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
		 * https://openapi-generator.tech
		 * Do not edit the class manually.
		 */
		var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
		    if (k2 === undefined) k2 = k;
		    var desc = Object.getOwnPropertyDescriptor(m, k);
		    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
		      desc = { enumerable: true, get: function() { return m[k]; } };
		    }
		    Object.defineProperty(o, k2, desc);
		}) : (function(o, m, k, k2) {
		    if (k2 === undefined) k2 = k;
		    o[k2] = m[k];
		}));
		var __setModuleDefault = (commonjsGlobal && commonjsGlobal.__setModuleDefault) || (Object.create ? (function(o, v) {
		    Object.defineProperty(o, "default", { enumerable: true, value: v });
		}) : function(o, v) {
		    o["default"] = v;
		});
		var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {
		    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
		};
		var __importStar = (commonjsGlobal && commonjsGlobal.__importStar) || function (mod) {
		    if (mod && mod.__esModule) return mod;
		    var result = {};
		    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
		    __setModuleDefault(result, mod);
		    return result;
		};
		Object.defineProperty(exports, "__esModule", { value: true });
		exports.axiosRetry = exports.Configuration = exports.ConfigurationV3 = exports.ConfigurationBeta = void 0;
		__exportStar(requireApi$1(), exports);
		var configuration_1 = requireConfiguration$2();
		Object.defineProperty(exports, "ConfigurationBeta", { enumerable: true, get: function () { return configuration_1.Configuration; } });
		__exportStar(requireApi(), exports);
		var configuration_2 = requireConfiguration$1();
		Object.defineProperty(exports, "ConfigurationV3", { enumerable: true, get: function () { return configuration_2.Configuration; } });
		var configuration_3 = requireConfiguration();
		Object.defineProperty(exports, "Configuration", { enumerable: true, get: function () { return configuration_3.Configuration; } });
		__exportStar(requirePaginator(), exports);
		var axiosRetry = __importStar(requireAxiosRetry());
		exports.axiosRetry = axiosRetry;
		
	} (dist));
	return dist;
}

var distExports = requireDist();

function createConfiguration(baseUrl, token) {
  const apiConfig = new distExports.Configuration({ baseurl: baseUrl, accessToken: token });
  return apiConfig;
}

export { createConfiguration as c, distExports as d };
//# sourceMappingURL=sdk-CZE8e3P6.js.map